Customer Reviews

Professional Android Application Development (Wrox Programmer to Programmer)

5 star:		(10)
4 star:		(8)
3 star:		(7)
2 star:		(3)
1 star:		(0)

 

 

The author clearly and concisely explains the fundamental aspects of Android programming. The coverage of Android topics is pretty comprehensive and the depth of coverage was just right for my needs. Mr. Meier provides some background information about mobile programming platforms in general, so the only real prerequisite for this book is familiarity with Java programming. The examples are also very informative and build new features incrementally, which keeps the focus on the most recently covered material, and reflects modern incremental development practices. This book, in conjunction with the excellent materials available online from Google, anddev.org and elsewhere, provide an effective staring point for developers looking to get started quickly on the Android platform.

This book was clearly written for seasoned developers. However, other books in this series are far more understandable. I'm really not sure why I did not like this book at all. I'll try to narrow it down. First, the writing style is not very engaging. It's also full of jargon that is never defined. For example, he uses the term URI, which has several component parts that he never defines. Worse, most of the code that he gives you to follow is never explained, at all. Not annotating code and using terms that you have never defined are a very bad trait. Third, alot of the material is a paraphrase of the android development documents, and there is really no new insight here. I think the core issue here is that we look for books not to sound like esoteric, terse documents, but this is what this book is. You will not learn how to program from this book. The code snippets jump all around and he tries to include everything about Android in this book which makes it seem just too much with incomplete treatment of many topics. I actually found the android tutorials less confusing.
Here is a typical example:

SimpleCursorAdapter
The SimpleCursorAdapter binds Views to cursors returned from
Content Provider queries. You specify an XML layout de'nition and then bind the value within
each column in the result set, to a View in that layout.

Upon re-reading it slowly and thoughtfully, this explanation does make sense. But we have not gone over content providers yet, and he has not talked about SQL queries with SQLLite in Android yet. Nowhere does he mention this, and again it's more like it's lifted from the android documentation without any explanation. This is an example of the style of writing that you'll be seeing. It's abstract, dense, and drab.

An example of the odd chapter organization is Chapter 5: Intents, broadcast receivers, adapters, and the internet. So we talk about intents and broadcast receivers, then view-related database interaction (which is what ch. 6 is all about), and then network communication (as opposed to putting it in its own chapter). It is like I am learning everything out of order with constant references back and forth (like a to do list example followed by an earthquake example, then going back to a to do list example). This is why I said it's dense and organized like spaghetti with no clear beginning and end.

At its worst, this book is a copy and paste of the android docs already available online. At its best, it is a paraphrase of the android docs already available online, with additional insight and code samples.

The extra insight is enough for me to be glad I bought it - it occasionally gave just enough additional perspective beyond the android web docs to make things "click" that I had not yet fully grokked. The code samples are useful, but the author himself says that they are sprinkled with bad habits, and I agree. He explains that it was for the sake of simplicity. I think it's more likely that he wrote the code, then wrote the section on best practices, and then realized that the code was suboptimal but had to meet a deadline.

In summary, worth my money and my time, but not truly impressed.

I was struggling with Android documentation (there is a lot of it but can be improved a lot, although the Notepad examples are very good) trying to understand the programming concepts for G1. So I got this book on pre-order and it was worth waiting for. Plenty of examples, code snippets, very good and clean explanations. I like author's approach of taking an application (Earthquake) through a series of improvements, so you can learn it gradually, from simple to more complex (and sophisticated) approach.
It is hard to cover a massive SDK in 400 pages but it is enough to learn basics and then start digging with some understanding and confidence into the on-line documentation. I am recommending this book to anybody who wants to learn the principles of G1 platform programming. Great job Reto!

It seems the book was written before the first release of Android was actually finished - it contains numerous references to nonexistent/changed Java entities (although the author does identify and point these out).
I would recommend this book for the absolute beginner, but for more experienced Java programmers you can probably get even better information freely by searching Android online forums and by also looking through Google's Android code samples on the Android project homepage.

I muddled my way through the docs on developer.[..], floundered around for a while, and then picked up this book. I must admit, I'm glad I did. Although I'd say the first four chapters present essentially the same material you can get from the free online docs, they do so in a much more coherent way. The ordering of the material made a lot more sense than the online docs, too - for example, services aren't mentioned in this book until chapter 8 (whereas they're mentioned on "page" one of the online docs). This presentation resonated with me, and made everything "click".

The organization of this book is, IMHO, the only useful way to organize a technical book, which is to explain the concepts behind some key point, followed by a working code example, which can be followed incrementally by the reader. Each example is presented in the simplest way possible, and subsequently refactored to use more complex (but more manageable) "convenience" features. This *is* a Wrox book - so there's almost as much code as there is discussion text. You won't get anything out of this book unless you plan to study the examples very carefully (and in many cases, dig down to figure out why certain code works a certain way - especially in the "advanced" chapter 11).

One concern I had, going in, was that the book was written for Android 1.0, but the current (as I write this) version of the Android SDK is 2.0. Fortunately, the differences were slight, and didn't make it hard to follow along at all. There were only really three noticable differences between the 1.0 SDK that the book was developed against and the 2.0 SDK I was following along with. Chapter 7 on the maps API was outdated (The book says you can use any string as your "maps API key". That was true when the book was written, but is no longer the case - you now have to register with Google to run the maps demos.) Chapter 9 included a long section on "GTalk" which has actually been removed completely from the API (this is, in fairness, referenced as a possibility in the book), and the Bluetooth API has changed considerably since 1.0. Otherwise, the code samples all worked "out of the box". Of course, there's no coverage of the NDK (Native Developer Kit), which was introduced with Android 1.5.

This book does a great job of presenting the overall end-to-end Android application development experience. One area where I thought coverage was lacking, though, was UI and layout management. This is probably the most important aspect of Android application development, yet there's very little content in this book about it. Also, this book is about Android, specifically, not about mobile application development. Terminology such as "Edge", "3G", "GPRS" and "LAC" are thrown around but not defined, and there's not much discussion regarding designing (or redesigning) for a mobile device - the author assumes you already know _what_ you want to do, and you're just trying to figure out how to do it in Android.

Although the online documentation for Android is very good, I much prefer to have a coherently written book that I can flip through for reference. In learning Android I have found Mr Meier's book to be absolutely invaluable. It is written from the point of view of a professional, working programmer and as such is it very readable.
Although the book covers all of the important aspects of Android and to a reasonable depth, I think it would be great to see some follow-up books from the same author that focus on particular aspects of Android (like UI or interprocess communication for example). A well-thumbed copy of this book is now on my desk at work (along with old cups of coffee and various other bits of clutter).

This is the best Android book on the Amazon right now. Even then, it is simply a better organized version of the SDK documentation. In fact, you learn more from reading the SDK documentation than reading this book. Most of the code are skin deep, probably an extraction from the APIDemo, with no in depth thoughts.

Would I read it? Well, if you already read the SDK doc, I didn't feel like I learned anything. Even with such harsh judgement, this book is still better than the rest.

Someone please write a decent Android book please!!!!

I bought this on the strength of the other Amazon reviews, but was disappointed. I have years of programming and application design experience, some in Java, but none with mobile applications or Android. At the beginning of the book is a section on "who this book is for" and it says you don't have to know Java, mobile development or Android to get through the book. This is false. While there is a lot of information in here, it is presented piecemeal and in a disorganized fashion, leaving one to hunt all over Google's Android website to complete the partial explanations one finds in the book. In addition, take note that it was written for Android 1.0;the most current Android version is 2.0 and is somewhat different. Having used other Wrox books and having found most of them very logically organized, with clear explanations of the code, I was surprised by this one. I'd suggest the author include more complete descriptions of the code and the terms used, how to set oneself up in the IDE, and some appendices containing information about the most used classes. The book has useful information, but it is not for those new to Android.

This book will help you learn Android programming, if you know Java and have a little experience with UI. But the index is sparse, and inhibits using the book as a reference. All the classes and methods covered in the book ought to be indexed.