Chapter 6: From Microwaves to Pocket PCs: Special Project Types
Overview
If you re like most Visual Studio .NET developers, as soon as you launched the program, you dashed off and created your own Windows application to see how the whole system had changed. After a while, you got bored and moved onto ASP.NET Web applications. Then, on the seventh day, you crowned yourself a guru and decided to rest.
However, like many programmers, it s just possible you may have missed some of the fresh new project types you can create in Visual Studio .NET ”projects we ve never been able to create before, or at least, without ten big headaches .
Creating a Windows service, for example, was previously a big-time problem: you either had to make seven zillion API calls and perform some low-level registering, or had to buy an expensive third-party component. Yet, no matter which option you chose, the process was still dodgy as hell, and most people who needed this functionality skipped across to C++. Not so in .NET: creating a service is pure simplicity.
Then there s the Console application, which gives you a DOS-style window for those times when a user interface isn t of prime importance. Yes, you could create these in Visual Basic 6... if you had the patience of two saints. Now, you just create a project, add a few function calls to the Sub Main procedure, and hit the Start button. Easy.
Then we have the Mobile Internet Toolkit (MIT). With this little baby, you can create Web applications to run on anything from mobile phones to microwaves, in almost the same way as you d put together an ASP.NET Web site.
Finally, we have the ability to create applications for small portable devices, such as Pocket PCs, with the smart device application project type. The old days gave us eMbedded Visual Basic to do this, but programming inconsistencies and sticky development techniques made it a rough ride for developers. No more.
But still, each of these project types has its own little quirks and special requirements, and that s what this chapter is here for. It ll explain the core concepts, then show you how to get up and running with each of these three special project types in no time at all.
Sitting comfortably? Then I ll begin .
Plug into Windows: Creating Your Own Windows Service
A Windows service is one of those often-invisible programs that typically start with the operating system and hang about, silently running, until you shut down. Such services include virus checkers, disk-monitoring applications, and security programs.
If you wanted to create one of these programs just a couple of years ago, you d either have to buy an expensive third-party VB add-on to assist in the process ”or learn C++. In Visual Studio .NET, you can just do it directly in your fave programming language, in about five minutes flat.
How? Well, start off by creating your own Windows Service project in Visual Studio .NET. (See Figure 6-1.) You ll be shown a relatively blank design screen. What you do next is really up to you.
Figure 6-1: Creating a Windows Service project
One of the most common procedures in designing your Windows service is to add a Timer component and have it fire your service code every x seconds or minutes. How can you get this to work? While still in Design mode, open the Components tab of the toolbox and drag and drop a Timer component onto your service. Change its Interval property to the number of milliseconds between each time you want your code to run. (Remember, 1,000 milliseconds equal one second. If you want your code to run every ten minutes, for example, set this to 60000.) Next, add code to respond to the Elapsed event of your timer; this code may check for the availability of a Web site, process any outstanding database requests , remove redundant files, perform some form of calculation ”anything really.
Another component that you may wish to use in your service is the FileSystemWatcher. This enables you to monitor a particular file or directory for changes. (See Watching a Directory for Changes in Chapter 7 for more information.) When these occur, events are raised. You can use this to dynamically monitor an area on your machine for alterations. As an example, you may be creating a system that keeps backups alongside an audit log, or records important system file changes in the event log.
A further possibility is to create a service as the server part of a remoting solution. (See Which to Choose: Web Services vs. Remoting in Chapter 7.) Your service simply sits in the background, waiting for clients to connect in and talk .
You can also add code to respond to the overridden OnStart and OnEnd events. These are added by default to your service ”just add code as necessary. For example, you may run a Timer1.Start during the OnStart event and a Timer1.Stop at the OnEnd event.
Your service also has the ability to override other events, such as OnPause , OnContinue , OnShutdown , and so on. You can respond to these by, in the Code window, selecting ( Overrides ) from the first dropdown box, and the event in the second. A skeletal overrides event will be created for you. Again, add code as you deem fit.
So, you finally decided how to design your own service and have just finished coding. Next, set its properties. To do this, open your service in Design mode and click on a blank region of the screen. In the Properties window, alter the Can settings (such as CanPauseAndContinue and CanShutdown ), typically depending on the events you have coded. You may also want to change the ServiceName .
Installing Your Service
Well, that s your service finished, but to install it we need to perform one last step. Right-click on your service in Design mode, and select Add Installer. This adds a new component to your project, containing a couple of objects that are used to provide details of your service during the installation. (See Figure 6-2.) If you don t add this installer component, the installation simply doesn t work.
Figure 6-2: Setting up our installer component
| TOP TIP | If you want to add special code to run during installation, you can do this by responding to some of the events behind this installer. Find out more by looking up Windows Service applications, adding installers to in the help index. |
Peruse the properties of the two objects added: typically ServiceProcessInstaller1 and ServerInstaller1 . The most important properties here are the DisplayName , which is the friendly name given to a service; StartType , which determines whether the service starts Manual or Automatic ; and Account , which determines the account your service logs on under. Edit if required.
And then? That s it! Just click on Build 
Build Solution to compile your application.
How do you actually get your service up and running? Well, include your project in a regular VS .NET setup and it ll do the job of installing it for you. Alternatively, you can go manual and use the InstallUtil.exe application to get it installed. Launch the Visual Studio .NET Command Prompt and type the following line:
InstallUtil.exe c:\YourProject\bin\YourApp.exe
Make sure you pay attention to the messages from this utility. If all is well, you ve just completed your installation. Use the Server Explorer in Visual Studio .NET to check out the services running on your local machine (or others on your network). (See Figure 6-3.) After installing, yours should now be in the list; right-click and select Start to set it off. You can alter whether it starts by default by using the Services application (Program Files Administrative Tools Services), or setting the StartType property previously mentioned.
Figure 6-3: Viewing Services via the Server Explorer
But what good would be an install without an uninstall? Here s how to remove your Windows service using the InstallUtil.exe prompt once more:
InstallUtil.exe /u c:\YourProject\bin\YourApp.exe
And that s really all there is to know about creating your very own Windows service. Easy!
Get the DOS Feel: Creating a Basic Console Application
Very few developers ever attempted to create DOS-style console applications using previous versions of Visual Basic because it was just too darn difficult. Ever craving for a challenge, I went the whole hog ”and even wrote an entire magazine feature showing exactly how it could be done. But, admittedly, it was bloomin difficult.
Thankfully, with the release of Visual Studio .NET, Microsoft has realized console applications are back in fashion ”and added built-in support for DOS-feel applications.
To get started, simply create a new project of the Console Application type. You ll be shown the simplest of Code windows ”one module containing one method, Main . This Main method is the procedure that will run by default when your application fires. (See Figure 6-4.)
Figure 6-4: Say hello to the home of your console code!
What can you do from here? Well, console applications have really just a few core commands, all of which are available through the System.Console namespace, intrinsically available to your program. Let s cover the important ones now.
First, you need to know how to spurt something out at the user. The following code will print the specified line out to the console:
Console.WriteLine("Welcome to the Automatic Data Processor") One way of just appending text to the current line is by using the Console.Write method. Here s an example:
Console.Write("Processing ...") ' start processing Console.Write("...") ' more processing Console.Write("... finished") You ll also want to know how to receive input from the user. This can be done through the Console.ReadLine function, as so:
Dim strResponse As String Console.WriteLine("Enter your age: ") strResponse = Console.ReadLine Console.WriteLine("You are " & strResponse & " years old") How about adding blank lines? It s as simple as writing out an empty string:
Console.WriteLine("") And what about incorporating a pause, for a press return to continue moment? Just do a Console.ReadLine without bothering to record the results:
Console.WriteLine("Press return to continue...") Console.ReadLine() After that, you can continue coding away as normal. Add functions, call Web services, read and write files. Your console application is no different to any other in the .NET range, except that it lacks any real user interface. And, if you re writing one of those applications that performs a bundle of data processing at 3:00 A.M. or executes a routine administrator task, that s absolutely perfect. Those sort of applications suit the formal, no-frills console application look wonderfully.
Well, that s all you really need to get going with your own console application. (See Figure 6-5.) Simply press F5 to run and test, or compile (select Build Build Solution from the menu), open up a command window, and run the executable in your Bin folder. Enjoy!
Figure 6-5: My sample console application in action
| TOP TIP | Console applications include built-in support for reading from text files (rather than pausing for user input) and outputting to text files (rather than sending text to the screen). To take advantage of this, use the SetIn and/or SetOut methods of the Console object, passing in new TextReader and/or TextWriter objects, respectively. For more information, look up Console class, about Console class in the help index. |
| ANOTHER TOP TIP | Want your console application to run at set times? Click on Programs |
From Mobiles to Microwaves: Creating Applications with the MIT
For a long, long time, Microsoft has been touting this dream of information on any device, anywhere , anytime . But, at least when it comes to Visual Basic developers, the company hasn t done much to prove it. That is, until now.
Coinciding with the first release of Visual Studio .NET, Microsoft unveiled the Mobile Internet Toolkit, a neat Visual Studio .NET-integrated extension to the .NET Framework. MIT is a program that allows you to write your own Web applications that can be displayed on almost anything ”from mobile phones to microwaves, Internet Explorer to handheld PDAs. Develop once and run anywhere.
How does it work? Well, after installing the MIT, you get to create a new type of project, a Mobile Web application. (See Figure 6-6.) Here you can design your minimalist application. It can do anything that your regular ASP.NET applications can, but, due to the limitations of some of the devices that may use your application, you re best keeping the actual graphical side to a minimum. Next, you make your application available as you would a regular ASP.NET Web app.
Figure 6-6: Creating a new ASP.NET Mobile Web application
When your application gets requested over the Net ”through whatever device ”the MIT steps in and figures out exactly what sort of machine is asking to view your pages. It then configures the output appropriately (that is, a certain dropdown box-style control will look like a regular dropdown on some devices, whereas on others it will render as a clickable list), and then sends your page down the wire in the language spoken by the device ”HTML, cHTML (Compact HTML), or WML (Wireless Markup Language).
In short, the MIT allows you to create intelligent , mini Web pages that can be viewed on practically any device. You design once and let the MIT handle all that sticky plumbing you really don t want to get involved in.
| TOP TIP | Microsoft is slowly renaming the Mobile Internet Toolkit to ASP.NET Mobile Controls . It is, however, being awfully inconsistent about the process. Many parts of the Microsoft site use the terms interchangeably. Just keep in mind that the two terms refer to the same thing. During the rest of this section, I m going to stick with Mobile Internet Toolkit. |
Creating Your Mobile Web Application
How do you go about creating your own mobile applications? First off, you ll need to access the MIT. If you re using Everett (Visual Studio .NET 2003), it s actually built into Visual Studio. If you aren t, however, or you want to access the latest device updates, you ll need to surf down to msdn.microsoft.com/vstudio/device/ mitdefault.asp . The main MIT setup is a cool 4MB download. Just follow the simple installation wizard to get started.
Next, launch Visual Studio .NET and create a new ASP.NET Mobile Web Application project (or quite simply a Mobile Web application, if you aren t using Everett). You ll be shown MobileWebForm1.aspx. On the page, you have a small Form1 object. This represents a page on your device. Because most mobile pages will be relatively small, Microsoft decided to allow you to create a bundle on just one page (along with, naturally, a code method of switching between them). The first form on the page is the first to be displayed when the page is accessed.
You can either simply start typing in this Form control, or add controls, by dragging and dropping from the Mobile Web Forms tab in the toolbox. You ll be able to instantly figure out most of these from their icons: the Label, the TextBox (with its useful Numeric property for number-only input), the multiline TextView, the Command button, the Link, the SelectionList, the Image control, the excellently rendered Calendar control, and the validation controls. (See Figure 6-7.) You can add code to respond to most of these items just as you would a regular ASP.NET Web application.
Figure 6-7: Designing our Mobile Web application
Other controls aren t quite so obvious however. The DeviceSpecific component allows you to target content at devices bearing particular properties, for example. One real favorite, however, is the PhoneCall control. Set its Text and PhoneNumber properties, and, on supporting phones, it ll turn into a link that allows your user to directly call that number. By default, if a device doesn t support dialing (Internet Explorer, for example), it ll display the Text and PhoneNumber properties alongside each other instead ( {0} {1} , the AlternateFormat default). Another way of handling this could be to put your own text in the AlternateFormat property and specify a link for the AlternateUrl .
So, you ve added a few neat controls to your first form. Next, you begin coding in practically the same way as you would an ASP.NET Web application. Respond to Click events, change properties, and add code to respond to the form Activate event (the Web page Load equivalent).
Writing Mobile-Aware Code
Most of your code will be relatively standard and nothing special. But there are points where it s useful to write code that specifically finds out more about the device using your application. Enter stage left, the aptly named Device object. To demonstrate its use, I might run code similar to the following behind my form Activate event:
Dim blnMail As Boolean blnMail = Device.CanSendMail
Here, I m checking whether the device can respond to the mailto: tag. If it can, I might set a certain Link control to an email mailto: link. Otherwise , I might change it to point to a Web site. Here are the top dozen Device properties:
-
Browser : Whether it s IE, Pocket IE, Microsoft Mobile Explorer, MyPalm, or some other beast , the Browser property gives you the name of your client browser.
-
CanInitiateVoiceCall : Returns a True if the device can call someone.
-
CanSendMail : Returns a True if the device supports the mailto: method of sending email, such as a Link control that has the NavigateUrl property set to mailto:karl@karlmoore.com.
-
Cookies : Returns a True if the device supports cookies.
-
HasBackButton : Can your user move back? This property returns a True if they can. This is great for deciding on whether to hide or implement your own Back button mechanism.
-
IsColor : Returns a True if the device uses a color monitor.
-
IsMobileDevice : Now, is that really a mobile, or are they just faking it with Internet Explorer? This property returns a True if they re using a recognized mobile device.
-
PreferredImageMime : Returns the MIME type of the image content preferred by the device. You may wish to check this before setting the ImageUrl property of an Image control. If a GIF file is preferred, it ll return image/gif , and, for a WBMP, it ll return image/vnd.wap.wbmp ”otherwise, you re probably safe displaying a regular bitmap.
-
ScreenCharactersHeight : Returns the approximate number of lines you can get onto a screen.
-
ScreenCharactersWidth : Returns the approximate width of the display in characters .
-
ScreenPixelsHeight/ScreenPixelsWidth : Returns the approximate height and width of the display in pixels.
-
SupportsBodyColor : Returns a True if the device can display the backcolor of a form.
-
SupportsBold/SupportsItalic/SupportsFontName/SupportsFontColor/ SupportsFontSize : Allows you to check whether certain text properties are available on the device.
-
Plus all the regulars: When using the Device object, you get all the usual things you find when working with the Request.Browser property, such as the ability to retrieve the browser version, check the platform, and so on.
| TOP TIP | Instead of writing code to check the capabilities of a device and then changing its properties accordingly , you can configure your controls to override certain properties automatically depending on a filter. This helps cut down on plumbing code. You can learn more about this by looking up mobile controls, overriding properties in the help index ”or check out the Going Mobile chapters in another of my books: Karl Moore s Visual Basic .NET: The Tutorials. This title also demonstrates fresh techniques for handling images, without having to handle the aforementioned PreferredImageMime property. |
While writing your code, you might also want to watch out for a couple of state management differences between regular ASP.NET Web applications and your mobile sites. Firstly, most mobile devices do not support cookies. If you absolutely need to store something on the user s machine, insert it into the query string and get the user to bookmark the page. Secondly, any ViewState information is stored on the server (a history of ViewState is also maintained ). As an alternative, use the Session object to store information for a user: it s more flexible than ViewState , you can access it from any page, and only one copy is stored at a time.
So, you ve designed your first form, used a handful of nifty controls, and added a little mobile-aware code ”now you re ready to move on and create the second. Well, to add another form, simply drag and drop a new Form control onto your page, set its ID and Title properties (optional), and begin adding controls and coding as before.
You ll also want to know how to move between two forms. You can do this in two different ways. Firstly, you can use a Link control and select your second form from the dropdown list of options in the NavigateUrl property. However, the most common method is to do it in code, by setting the ActiveForm property of your mobile page to your form control, like this:
ActiveForm = Form2
If you want to add a whole new mobile page to your project, select Project Add New Item, then select a new mobile Web form and click on Open. You can now continue designing as normal. But watch out: you can t redirect from one mobile Web page to another using a regular ASP.NET Response.Redirect . Instead, you have to use the following function of your mobile page (don t look at me!):
RedirectToMobilePage("mypage.aspx") Testing Your Mobile Web Application
What next? Well, you ve learned all you need to put a mobile Web application together, so finish off your project and get testing! Hit F5 to test your program in Internet Explorer. Better still, download the Microsoft Mobile Explorer emulator, which is available from the MIT download address given earlier. Other recommended test browsers include the Nokia Mobile Internet Toolkit from www.forum.nokia.com (see Figure 6-8) and the OpenWave Mobile Browser at developer.openwave.com/download/ .
Figure 6-8: My sample application in the Nokia simulator
And, when you re ready to roll your site out to the world, what do you do? Simply treat it just like a regular ASP.NET Web application. (See the Where to Put Your Files with an ASP.NET Host tip in Chapter 3 for more information.)
That s all you need to know to develop applications that can run anywhere, any time, and on any device! Amazing stuff, and definitely something you can incorporate into that next big project, right?
Portable Computing: Creating Apps for Your PDA!
As devices such as the Pocket PC become almost as powerful as the machines sitting on our desks, it makes sense that more and more developers will want to start creating applications directly targeted at such platforms.
In the old days, however, this was pretty difficult. You had eMbedded Visual Basic, which allowed you to create Windows CE applications, but programming inconsistencies and sticky development techniques didn t make for an easy ride.
But, with the release of Everett (Visual Studio .NET 2003), Microsoft has introduced a new solution. It s a two-part fix that allows you to create applications to run on resource-constrained devices such as the Pocket PC and Windows CE handhelds, in almost the same way that you d create a regular Windows application.
The first part to the solution is the .NET Compact Framework. This is a mini version of the .NET Framework, weighing in at almost 2MB (compared with 20MB+ for the full Windows version). The .NET Compact Framework runs on your device and includes a large selection of the core Framework classes, including a wide range of controls, plus even stretches to supporting Web services.
The second part to the solution is the ability to create a smart device application. This is like a tiny Windows application, with a typical Pocket PC form defaulting to 240 — 320 pixels. The program is built on top of the .NET Compact Framework (which can run on your development machine) and can be packaged into a CAB file and installed directly on your target device.
| TOP TIP | Are you using Visual Studio .NET 2002? Although the .NET Compact Framework betas allowed VS .NET 2002 users to create smart device applications, the final release ships only with Everett (Visual Studio .NET 2003), which means that you either upgrade or ship out. |
Building for the Compact Framework
How do you get started with developing for the .NET Compact Framework (CF)? Simply fire up Visual Studio .NET and create a new smart device application. You ll be presented with a wizard, asking what sort of application you d like to create.
You ll need to choose the platform you wish to target and the type of application you d like to create. As the industry moves more toward Pocket PC devices, the norm here would be to select a Windows application running on the Pocket PC.
| TOP TIP | Looking for a niche software market? Hundreds of developers create component libraries for the COM and .NET development worlds . But how many create class libraries for Pocket PC developers? Perhaps libraries that overcome the limitations imposed by the trimming of the .NET Compact Framework? |
After selecting your project type, you should be presented with your first form. From here, you can begin development just as with a regular Windows application, with a few obvious size restrictions. (See Figure 6-9.)
Figure 6-9: Visually designing my Pocket PC application in Visual Studio .NET
The big thing to remember here is that the framework supporting this type of project is not the .NET Framework. It s the .NET Compact Framework. This means that, although you can still develop your program as you would a regular Windows application, not everything will operate exactly as you expect.
For instance, controls will look different and may vary slightly in the way they operate, and certain classes may be unavailable or work in an altered fashion. But it s generally similar: you can add extra forms and open them using standard techniques; you can create smart device class libraries and reference them as you d expect; and you can add Web references and interact with Web services as usual.
On the whole, it s a relatively easy shift.
So, you ve developed a neat Pocket PC project and want to give it a test run. But how? Simply follow the usual VS .NET debugging techniques: select Debug Start to begin. You should be asked which device you wish to deploy your application on.
For example, creating a Windows application for the Pocket PC will allow you the option of using the Pocket PC 2002 emulator (see Figure 6-10) or a live debug session with a connected Pocket PC. Choose your target and select Deploy.
Figure 6-10: A sample application running in the Pocket PC 2002 Emulator
If the .NET CF hasn t yet been installed on your device, VS .NET will install it for you and then run your application. This is where you step in: test your application, step through your code, and identify bugs . Just the same as with regular Windows applications.
| TOP TIP | The first time you run the Pocket PC 2002 emulator, you ll probably be asked to set up the device, tapping through the welcome screens. The emulator is actually a fully working version of the Pocket PC operating system and therefore reacts in the exact same manner. It s one of the best emulators I ve seen. |
Deploying Your Applications
You ve created that application and done the whole testing thing. Now you re ready to roll it out to .NET CF devices around the globe. What s to do?
First, as with regular Windows applications built for the full .NET Framework, a copy of the framework needs to be installed on the machine. This can be installed in RAM by downloading the setup from http://msdn.microsoft.com/vstudio/device/golive.asp. This is absolutely required: attempting to run a smart device application without the .NET CF installed will raise an error.
| TOP TIP | Today, most devices will allow the .NET Compact Framework to be installed only into RAM. However, most future Pocket PCs and smart phone devices will come with the .NET Compact Framework already installed in the ROM. |
Second, you need to create your application setup. This is fully automated: simply select Build Build Cab File from within your smart device application project.
| TOP TIP | If you wish to distribute a bundle of files with your application (game images, for example), add them by right-clicking on your project and selecting Add |
Inside your project \Cab\<Configuration>\ folder, you ll find a variety of CAB files (alongside a mass of unimportant DAT files, which you may disregard). Each of these CAB files contains a version of your project specific to a particular processor for the platform you selected. For example, a Pocket PC application will generate versions for the ARM, X86, MIPS, and other processors.
However, as all Pocket PC devices are now standardizing on the ARM v4 processor, the most important CAB file in the list is MyProject_PPC.ARMV4.CAB. This is your project setup, created for the Pocket PC (PPC) ARM v4 processor.
When you re ready to deploy, you can deploy the relevant CAB to your device using ActiveSync (a PC-device synchronization feature that many PDA users will be aware of) or by setting up a file share on your machine, copying the CAB file onto your device, then single-clicking to automatically install.
You d be forgiven for thinking the deployment portion of such smart device applications is currently a little immature. It was, apparently, something of an afterthought. You can expect improvements in the next revision (see msdn.microsoft.com/vstudio/device for the latest). Don t be surprised to find a bundle of third-party InstallShield-style solutions to hit the market shortly, too.
| TOP TIP | Want to test CAB deployment on the Pocket PC 2002 emulator? You can simply set up a file share, then copy the CAB file across the emulator ROM, and run! Here s how: first, create a folder containing the CAB file, then set it up as a shared directory (typically, right-click, select Sharing and Security, select Share this folder , and then click on OK). Next, in your Visual Studio .NET device project, select Tools |
Going On from Here
Although this brief introduction should give you enough fuel to get going with your own PDA applications, there s much more to learn.
For example, did you know that you can run the powerful SQL Server CE on your handheld? And you can write applications to create databases and access your data, perhaps even synchronizing live with a master SQL Server database? It s all true. (Check out the setup and help files in \Microsoft Visual Studio .NET 2003\CompactFrameworkSDK\v1.0.5000\Windows CE for more information.)
You can learn more about creating your own smart device applications by browsing the hidden samples distributed with Visual Studio .NET; they re in the \Microsoft Visual Studio .NET 2003\CompactFrameworkSDK\v1.0.5000\ Windows CE\Samples\VB\ folder or online at www.gotdotnet.com/team/netcf/ Samples.aspx. (Make sure you check out the MapPoint and Cave Man Hank samples!)
And, of course, Apress has their own plethora of books dedicated to the technology: try The Definitive Guide to the .NET Compact Framework by Dan Fergus and Larry Roof ($59.99, ISBN 1-59059-095-3) and SQL Server CE Database Development with the .NET Compact Framework by Rob Tiffany ($44.99, ISBN 1-59059-119-4).
But, for now, go and create. The shift is simple, and the results are pretty amazing.
EAN: 2147483647
Pages: 76