Author: Marko Gargenta
Publisher: O'Reilly, 2011
Pages: 268
ISBN: 978-1449390501
Aimed at: Java programmers
Rating: 4.5
Pros: Good explanation
Cons: Based on a single large example
Reviewed by: Harry Fairhead

Learning Android programming is made easier if you already know Java and have a rough idea how a modern UI framework is used. This book assumes that you know Java and have a fairly good understanding of most aspects of programming, i.e. it is not for the beginner. It also tackles the task of introducing Android using a single big example of a Twitter app. If you like to learn new technologies via a real world application then you will want and love this book. If you prefer to be told the essence of the idea and then work out how to use it all for yourself you still may be happy with this book because it does a good job of explaining things.

The first chapter takes us over the basics of Android. This is mercifully short, other authors please take note. Then we move on to Chapter 2 looking at the development "stack". Here we learn about the Linux variant that is Android and its relationship to Java and the Dalvik virtual machine in particular. You don't really need to know this stuff but it is interesting and the chapter is again short.

Chapter 3 is where things really get started. Installing the SDK and Eclipse and a basic Hello World project also provide a reason to explain the basic structure of an Android project - the manifest, layout XML, resources etc. This is quite fast paced so you need to stay awake. Chapter 4 builds on this with the start of the real world example - the Twitter App Yamba. Rather then follow the easy route and explain the UI we have the life cycle as an introduction followed by intents, sercices and content providers.

Chapter 5 provides an overview of the Yamba project - this is the overhead involved if you want to use a complex real world project to explain how to program.  However, at least the overview means you do get to see the whole elephant rather than having it exposed little by litte. 

Next we have the UI and this is a good introduction to both XML and code creation of the UI. The only problem is that as it is part of the bigger application roadmap there are many detours to deal with other topics that can't be left until later. In practice this turns out not to be too bad.

Chapter 7 is about preferences, filesystem, options menu and intents - which don't really fit together logically but they do as part of the application development.  Chapter 8 is about services and again this fits in more with the application than with a logical explanation of the structure of Android. In most books services are treated much later as something advanced. In reality they are key to most Android apps so this is perhaps a better way to do the job. A chapter on database follows and we now have an application that can do quite a lot. If you have been following and preferably by creating the app for real you will be more than settled in with Android.

Next we return to the UI but now we are dealing with more advanced techniques - creating widgets and using adaptors. Then onto broadcast receivers which are another traditionally advanced topic - but now we are getting towards the end of the book and the topics should be advanced. From here it's a fast downhill race to get through content providers, system services, the Interface Definition Language and the NDK. Phew.. that was a lot of work in slightly less than 250 pages. If you can keep up then you will be an Android expert at the end.

Overall this book is great - as long as you can cope with the pace. It also probably isn't as effective if you are simply reading it for ideas and missing out on trying to build the example app. What this means is that you need time to work with the book and this doesn't make it a fast track to Android. However, if you are happy with working through a single big example and have the time to put in this is a very worthwhile book. Recommended.