Java Development on PDAs: Building Applications for PocketPC and Palm Devices

Share

Java Development on PDAs: Building Applications for PocketPC and Palm Devices
| 2003-06-05 00:00:00 | | 256 | Java


With the release of Java 2 Micro Edition (J2ME), Sun Microsystems opened Java to the rapidly expanding Personal Digital Assistant (PDA) market. This comprehensive tutorial and reference provides an in-depth look at developing PDA software with J2ME and PersonalJava, covering both Palm and PocketPC devices. Succinct and practical, JavaaA A Development on PDAs focuses on real-world programming tasks with extensive code examples and an end-to-end PDA application demonstrating techniques for integrating devices with the enterprise via Web services. This book describes the J2ME platform and PersonalJava and discusses design issues specific to resource-constrained devices. It also provides in-depth coverage of networking and Internet access, the user interface, data storage, and integrating PDAs into the corporation.You will learn to develop Java applications for PocketPC and Palm devices through in-depth coverage of: *J2ME configurations *CLDC and CDC profiles *Selecting a PDA for development *PDA development tools *Designing for constrained computational capability *Designing for constrained screen and memory size *PDA user interfaces *Storing information on the devices *The Generic Connection Framework *Internet access from a Java PDA application via a GSM phone and Bluetooth *Accessing Web services from Palm and PocketPC devices JavaaA A Development on PDAs concludes with a look into the future of PDA technology and the expanding role of these devices in the enterprise. Written for anyone with a basic knowledge of Java, this important resource is a must-have for all those interested in the Palm OS and PocketPC markets. 0201719541B05292003

User review
No complains
I bought it for a friend and never heard a complain about it. I guess it's a good book.

User review
All the basics of programming PDAs
While I do not currently write anything for PDAs, it is clear that the majority of the growth in the use of new computing devices will be in handheld devices. This will of course require an enormous amount of new software to be built. While the power of the handheld devices continues to grow, convenience, if nothing else, will demand that the size remains small. This will limit the size of the screen and the amount of memory available. Therefore, while it is possible to port software used on desktop platforms to handhelds, it is not an easy task and even in the best of circumstances, significant changes have to be made.

In this environment, it seemed logical that I learn the basics of how to program PDAs. Since I am now primarily a Java programmer, this book seemed like a logical place to start. From reading it, I learned a great deal about how the programming of PDAs is done. The book opens with a description of how the Java standards relate to PDAs as well as the availability of Java implementations on the most popular PDAs. This is followed by a list of ways to obtain the software needed to start developing software for PDAs. Chapter four covers some of the major restrictions encountered when programming PDAs. This chapter is essential and was the most interesting. The remaining chapters contain demonstrations of programs that create screens displaying the usual range of user interfaces. Buttons, checkboxes, filedialog boxes, alert boxes, textboxes and the various layouts are illustrated with code. Some of the common actions, such as serializing object data, accessing JDBC databases and using Internet protocols are incorporated into the programs. As an experienced Java programmer, I found the programs fairly routine, although there were some differences that needed to be understood.

There are no great revelations in this book, just a solid introduction to one area of computing where the growth over the next decade could be incredible. I have elderly relatives who have never touched a computer, and yet they have cell phones and are learning how to use some of the advanced features.



User review
Review of `Java Development on PDAs`
So this book started well, with lots of sensible thoughts like making all the source code available for download to avoid long listings in the book itself. Although as I read through there still seemed to be a fair amount of code (e.g. p109 -113 is all code) but presumably this was still only the `critical` bits of code needed to understand thte points being made. Generally I thought the first three chapters of the book were very strong - the description of CDC, CLDC and MIDP left me feeling more certain about what they actually are:

CDC and CLDC are `configurations` which means JVMs with some basic APIs
MIDP is a `profile` which is additional APIs which will work on top of a `configuration`

Chapter two was particularly interesting, focusing as it did on the different types of PDA available, comparison of prices, relative market shares, and performance specifications for different PDA/Java combinations. Although naturally this look at the current market will date most quickly, it provides an interesting insight into PDA trends in this period. Overall the book gives a strong impression of having been written by a single developer (which it has) who has a lot of hands on experience with Java on PDAs, and thus has a lot of relevant advice to give. This is exemplified in Chapter three where we are taken through a selection of open source and cheap development toolkits, as well as the process of setting these all up to get started developing on the PDA.

Unfortunately after this strong start the subsequent chapters fall to some extent into the standard `work through the API` approach, so that while the chapter on user interfaces encourages us to consider carefully the restricted screen space on PDAs, the body of the chapter is simply a description of the different types of user interface component, rather than a more detailed look at when each of the component should be used and to what effect.

I don't want to be overly critical here since there is a burden on authors of technical works to make sure that important sections of the API are covered, however I find I am not really able to take in more than trivial amounts of code from the page of a book (I need to be running it and making changes to bits before I understand it). The screen-shots from the PDA help here, but really I wanted more from something in book form. Ideally I would like to see a paragraph or two on the pitfalls and advantages of using each kind of UI component in a PDA setting. Even better would be a sample project, where we work through two possible user interface solutions, one designed without much thought on the constraints of the PDA and one designed with the PDA in mind.

To be fair some general guidelines for developing on the PDA are outlined in chapter four but it is fairly short, and lacks examples. To make this book `really useful` rather than just `handy` I would like to see a much more rigorous analysis of two versions of a sample project, one done correctly and one done incorrectly from the PDA perspective. This kind of comparison is hinted at tantilisingly at various points in the book such as the comparison between SOAP, HTTPText and HTTPStream in the networking chapter. The author shows that he is capable of presenting the pros and cons of different alternatives in particular areas, so it is a shame that this approach could not be developed more thoroughly. The very short concluding chapter on Futures, only confirms the impression that more time could have been spent on this book to good profit.

Still, while I think the reader can rightly ask for more, there is still alot here - I am sure that anyone developing Java on PDAs would be well advised to have a copy of this book on their desk. We can only hope that the author will be given more time to develop the themes touched upon in this work in a subsequent publication.

User review
Do yourself a favor: Buy this book
When you want to dive into the field of actually program a wireless device you can easily find yourself become confused. One question is simply: What do I need to get going with the first project. And although it is a simple question to ask, it is not yet a simple question to answer, because it depends! The dependency is what device you want to address and what options you have when you want to develop an application.

This book is written by a humble and very competent programmer. He is humble because he just want to tell us how to code a PDA, be it PocketPC or Palm. He does not want to demonstrate much more than this. And this is how it should be, given the title of the book, because what he does is telling us all the steps needed. Here the authors competence really shows.

The book starts with a brief introduction to the J2ME configurations, the CLDC and the CDC API's. Continuing then to the MIDP profile where the author already demonstrates a simple generic MIDP applet. The next two chapters really rocks the boat: Here is compared the Palm and the PocketPC platforms with regard to J2ME, so if you have the choice then you can easily decide what to go for. In any case you will here find the most needed information: What development environment should you use for a specific platform - and where do you get it. The author brings links to a collection of no-cost tools and what more: All the links are correct!

At this point you really must begin to program at least a `Hello World` program for you selected platform. McBride helps you with every step in this for both platforms. He discusses JDBC, Internet access from the PDA's and how to use misc. connection methods, for example Infrared Connections or Mobile Phone. Everything is demonstrated with very good screen pictures of the PDA's or good program lists. He even demonstrates how to use web-services and the SOAP clients.

The last part of the book deals with the future, meaning technologies such as JXTA (dynamic peer-to-peer network) and ideas about Jini. Bluetooth was already demonstrated earlier in the book. Again, everything is written clearly and makes you want to start the programming now.

The book is highly recommendable! On no more than 239 pages including the index you'll get all what is needed to start doing your own development with confindence that it will work. I really believe that all the code in the book was tested. Do yourself a favor: Buy this book if you want to program JAVA on the PDA's!

User review
It is simple to program PDAs
It is a stark measure of how far computers have come that the author reminds us that today's typical PDA has about the same CPU power and 4 times the memory of the first Macintosh, and likewise of a comparable contemporary PC. So while you may be a programmer on a current workstation with heaps more memory and speed than a `constrained` PDA, migrating to it would still mark you as a power developer by the standards of a not so distant past.

If you are already programming in Java for a desktop, then this book will be an easy stroll in the park. The graphics and networking libraries are different from J2SE and J2EE. But this is only insofar as they have necessarily much less functionality, though retaining just enough to hopefully do what you need. Gnash your teeth at the loss of cool graphics, if you must, but that is how things are. The neatest part of the book is the descriptions on how to offload the heavy computations via web services. This may be new to you.

By the way, if you are interested in the book, also check out `MIDP 2.0 Style Guide` by Bloch and Wagner; also published by Addison-Wesley. The two books complement each other. The latter gives a high level description of the appearance and functionality of a UI on a small device. Wilding-McBride's book then shows code examples to actually let you do this, at least for PDAs. Surprisingly, neither book appears to reference the other, though they are by the same publisher and came out just a few months apart. So, at least let me do that for them here.