Home - Mobile Phone Programming

I've read several books on Android from cover to cover, and skimmed several others, and "Hello, Android" is hands-down the best introduction to Android development.

Here's why I say that --

You really can get through the book in a day or two. The explanations are clear, the topics focus on what's relevant to getting started in Android development, and when you're done you have the skills to dive into the SDK to continue learning.

There is a consistent example project that is developed throughout the book. I found this very helpful, because it showed me how all the different parts fit together. For example, launching activities from an existing activity, using multiple classes in your project, adding preferences, etc.

There are very few (if any) "gotchas" in this book. I followed the examples step by step without any problem. I think some people have used the book's online forum to ask about which packages to import, but when I used Eclipse it was done automatically for me. (By the way, all the files are also online.)

Even after having many months of Android development under my belt, I find that I still refer back to this book from time to time. That's saying something for a book that sets out to be an introduction.

Remember, this book is a great introduction. If you already know Android and are looking for a deep-dive, look elsewhere. But if you are curious about all the excitement around Android and have a few hours to spare, spend them with this book and find out what developing in Android is all about.

I have virtually no programming experience. Other than a solid beginner's understanding of LAMP (unix, apache, mysql, PHP and scripting stuff in general), I've never done more than fiddle with code. I do have a cursory knowledge of programming concepts and XML, but that's about it. I'm pretty much a curly brace language virgin.

Hello, Android does a solid job of introducing you to the fundamentals of programming for the Android OS -- it gives you a succinct overview of why you need to do 'XYZ' and when to do it. If you're looking for pages and pages of fundamentals and core concepts, you may want to look elsewhere because Hello, Android makes you hit the ground running and helps you immediately apply the quick concepts you just learned. This is excellent for a beginner like me because the results are immediate and gives you a sense of "this isn't so intimidating... I can actually do it!"

The one aspect I enjoyed about the book was that it gently gets the absolute beginner up to speed but then does less and less hand-holding as the tutorials moved along; this lets intermediate and advanced programmers move along at a brisk pace, but also forces beginners to think about previous concepts that were taught earlier. Instead of simply copying-and-pasting "recipe" code, it really challenged me to think and absorb what the author was teaching. This was invaluable for me as a beginner that likes to be challenged with more than just a simple 'copy and paste this code from page XX, then hit build and run'.

One intangible you won't find in the book -- the author is very helpful/responsive in the Pragmatic Programmer's forums, as are the other members. Any question I've had were answered (usually) within a day, and many times within an hour. For instance, I was having an issue with running 64-bit version of Java JDK in my Android dev environment. The author (and other members) were very helpful in getting my dev environment up and running. Needless to say, the community that goes along with the book is invaluable.

I've owned dozens of wrox, apress etc books since the 90s, and this is one of the few that I would not hesitate to recommend to both beginners and advanced programmers with no Java or XML dev experience. Get this book! 4.5 stars.

PS -- if you buy the paper version of the book, I'd also highly recommend the e-version. Having a PDF up side-by-side with Eclipse (Android's default IDE) is extremely useful.

At first glance this is a really good book on Android programming. The first two chapters set you up with the most basic knowledge you will need to get ready to program. The following 4 or 5 chapters are wholly frustrating. These chapters deal with making a Sudoku game. The author leaves many things unsaid. He will purposefully have you build your program so that it will have errors. Once to show your your mistake, once he just leaves an error in there for like 9 pages. The author will just throw random components out there that have nothing to add to what you are currently doing. At one point you are creating an "About" activity and the author randomly starts talking about themes. Maybe we should finish the program before we make it look pretty? Maybe we should finish our current concept before starting another one?

Aside from the beginning project, the rest of this book is quite good. Many topics are covered, including making widgets, 2D programming, 3D programming, live wallpapers, using SQL, publishing your apps and games, and more.

If you are a beginner to Java, get an intro to Java book first/too, the author assumes fairly competent knowledge of Java syntax, keywords, and the like. All and all not the worst book, but not the greatest. I, personally, would not recommend this book.

This book definitely started me off in the right direction for making my own applications for Android.
Although this application misses an important section, "Publishing your application", the book is on the design process of the applications.

The book starts you off by familiarizing you with how the Android is run and the general idea of its interface. Then come the example applications which can also be found online.
Each example application is a different use of the Android...
Sudoku, GPS tracking, MySQL, OpenGL, Browsers, etc... This shows you a basic example to a solution.
This book does everything it intends to do for a user of the G1 starting to program. I have never programmed in Java and XML(C and HTML, though), and this book managed to get me understanding and writing basic applications within several hours.

I wouldn't recommend this book if you don't understand basic code because the book does jump into it rather quick and has many technical words. However, for a small book of 200 pages, each summary is very concise and exactly what was necessary to learn the understanding of the material- if you really want more, Im sure Wikipedia and Android-forum along your side will solve all your problems.

The only problem I have with programming now, is customizing my applications to my liking. But this is just learning programming better.

I plan on having many applications on the market place after learning a bit more java, XML, and practicing just a bit!

Thanks and good luck G1 programmers!

I have been programming computers for more than 30 years. My background includes DOS Basic, c, C#, C++ .NET, but not Java.

I bought this book because I want to get started in writing some apps for my phone. I have found it to be the best beginning book available. I have looked at 3 or 4 others. It is complete, accurate and has real applications to develop. IT shows you how to set up the IDE and tells you where to get the tools. The author explains what he is doing but does not get bogged down in the details.

You should have a background in Java but if you have experience in some of the other languages out there you should be able to get by. A knowledge of XML would help too.

My recommendation for anyone trying to develop for the Android OS would be:
1. Get familiar with Java
2. get familiar with XML (rudimentary understanding)
3. Buy this book
4. Go for it!

I will be placing this author on my 'watch list' because his writing level is very comfortable for me.

I've been developing software for quite a while but I am new to Android, and Java is not my main forte. The first book I purchased, Wrox's "Android Application Development", left me wondering if I'd lost all my reading comprehension skills. So I browsed a lot of other books until I discovered this one. The writing is very clear, the examples are complete, and by building a Sudoku application you learn all the key aspects of Android development in a very logical way. The author also walks you through setting up, developing and debugging Android in the Eclipse environment, and guides you through preparing an application for the Android market. This is a very complete introduction to Android that never once left me scratching my head or frantically Googling for omitted information. Highly recommended.

This book covers a broad array of topics, it covers none of them in real depth and it is really really focused on Android - as opposed to Java. For my situation - it was perfect.

As a "read in a week, do the examples and lean a hell of a lot" type of book - it does the job well. If you know nothing about Android, want a crash course in the possibilities, and some basic intro on to how to realise them - this is the book you want. It's short, it's to the point and it will kick-start you into development. It's also way more digestible than the online docs if you're just starting out.
It will not turn you into an Android development ace; although it's such a new technology, you may be mistaken for one when you open your mouth. You'll certainly be able to "talk" a reasonable game when you're finished. If you are looking for a detailed Android reference or advanced programming manual type of thing - it's the wrong book.

It focuses on Android - not Java. You will learn NOTHING about Java programming, the pages deal exclusively with the Android system, and how to program it USING Java.

The book is divided up into 4 sections:

Section I : Introducing Android
------------------------------------
Chapter 1 : Gets the tools set up (Eclipse IDE, Android Development Kit plug-in and Android SDK) and has you compiling the obligatory "Hello World" project.
Chapter 2 : Takes you on a 5 minute tour of the Android system from bottom to top. It's useful, especially if like me you come from a non-mobile development context. Android handles
application life-cycle differently because of the resource constrained devices it's typically hosted by; this has major implications for your application implementation.

Section II : The Basics (Uses the construction of a basic Sudoku game as it's vehicle for teaching throughout the section)
------------------------------------
Chapter 3 : User interface (Screens, Dialogue boxes, Menus, Buttons etc.)
Chapter 4 : 2D Graphics (draw your Sudoku grid / numbers)
Chapter 5 : Multimedia (Audio / Video...to add those essential Sudoku sounds...)
Chapter 6 : Storing Local Data (remembering Sudoku options - handling saving of current game data when the game is paused [e.g. when a call comes in mid-game and Android context
switches out your application])

Section III : Beyond the Basics
------------------------------------
Chapter 7 : The Connected World - using the phone browser / browser view, JavaScript, web services.
Chapter 8 : Location and Sensing - using the host of other sensors (GPS, Accelerometer, light-meter, orientation etc) your device may have.
Chapter 9 : SQLite - using the ever-popular SQLite embedded database that comes with Android.
Chapter 10 : 3D Graphics - using the Android implementation of OpenGL.

Section IV : The Next Generation
------------------------------------
Chapter 11 : Multi-touch - how to
Chapter 12 : There's no place like home - creating widgets / live wall-paper
Chapter 13 : Write once, Test Everywhere - advice and tips on debugging / testing when faced with a large array of devices already in the wild.
Chapter 14 : Publishing to the Market - a basic overview of getting your application to those fee-paying mobile junkies.

My one gripe with this book is in Section II - you're in the mix...building Sudoku and it's done in a nice, incremental manner: you write a little code, compile it up and see it run. Gradually the game comes together and you get a sense of satisfaction from watching it do just that. Then, at a certain point, you'll find yourself writing code that uses functions you've not written yet....suddenly...POW...your code doesn't compile and you can't see the results of your new code. Obviously you dive forward, find the functions, implement them and hey presto, it compiles again. It's not a terminal thing; just out of the blue and a little frustrating.

Overall - I thought this was a really good book for someone a) who knows a bit of Java b) doesn't know Android at all. You could probably figure it all out from the online docs - but I bet you it will take a lot longer and won't be half as pleasant an experience! I'd recommend it to anyone starting out with Android.

This is exactly the book I wanted and what any developer who wants to learn Google Android Needs.

The author did an excellent job in just 200+ pages to give you core concepts and tips to start coding an Android.

Ofcourse in 200 pages he cannot explain all the details but google itself has good documentation also to learn those details.

My overall experience of Android SDK is that it is very powerful SDK which can do many things that other Phone SDKs were never able to do because of phone limitations. But also a bit disappointed in somewhat poor design of the API itself.

I will preface my review by saying I am a C# developer used to Visual Studio (up to version 2010). I love the Visual Studio environment. Eclipse was a little bit of a learning curve for me. But, I got by just fine.

Here is a book that took me about 3 days to read cover to cover. I've been programming for many years and this book was perfect for me. High level overviews are the best way to figure out how things work. He even provides links for you to find more information for things that truly interest you.

I don't agree with some of other reviews. I really didn't have any issues implementing the code in the examples.

My only complaint would be in the OpenGL section. I wish there was more comments in the code as to what each line was doing. I looked each up myself easily though.

Get the PDF, Mobi, and epub. Amazon doesn't appear to offer it on their site. So, I had to go to the publishers site (The offer all three for a lower price than buying the hard copy). That could change. I didn't really see a reason for the actual print version since I have a Kindle DX.

Regarding books, one of the things I appreciate the most is an honest relationship between title and contents. Unfortunately it's quite common to find books out there promising things they don't fullfill.

"Hello, Android" meets perfectly the commitment of its title. Don't buy it expecting a reference manual of Android because it' just an introduction to this platform, and I must admit that it does the work gracefully. It's quick and brief so it tells you the essential and gives you resources for further research such as the sample projects that can be free downloaded from the book website. A nice aspect to highlight is the hands-on approach, throughout the book concepts are illustrated with lots of code. Furthermore a Sudoku game is parcially developed during a couple of chapters.

So I basically recommend this book for beginners mainly for two reasons:

1. Starts from the Scratch: Nothing is assumed so it's a good point to start out as Android developer.
2. Brevity: I don't have time for an eight-hundred-pages book to start to develop. I'll deal with the ins and outs as I go, not before.

Of course, like any book about Android, Java (or C++, C#, etc) basic understanding is recommended.

I have been a developer for nearly 30 years now and I have bought an incredible volume of books over this time period. This book, Hello Android was one of my favorites to actually "read". This book covers the complete creation of a game from start to finish. What I like about the book is that the author explains what we are goig to do, shows the coding to make it happen, explains why we are coding it that way and if it is something graphical he shows us what it should look like. What more an you ask for? I also like how he can guess what your question may be and answers it. For example he talks about colors values( alpha, red,green & blue). My first question was "What the heck is alpha". I turn the page..then there it is he explains it. This book was enjoyable as opposed to so many other books I have bought. I sat down and read half of it while my wife was getting her hair done. To me it read like a novel.

I can not find anything bad to say about this book. I read some of the other reviews and I was surprised by what others had wrote. I can only guess that their negative responses are a result of their limited experience.

The point of the book is to get one started in Android programming and that is exactlty what it does. I am hoping I will find other books written by this author.

The title, "Hello, Android", is perfect, because this is an introduction to Android. This is not designed as an exhaustive reference, nor should it be. Instead, it is the perfect length for quickly coming up to speed on the basics.

I am an experienced Java developer, and this book helped me learn Android quickly. It does not waste time explaining how to use Java, so if you are an absolute newbie, this might not be for you.

Android is rapidly evolving, and Ed is doing a great job keeping up with changes to Android. You can also get the PDF version, and Pragmatic Bookshelf lets you download beta chapters as they are updated.

I think this book is a good starter for those looking into Android, but isn't a one stop shop. The program that you work through is pretty extensive, and there are a lot of hints and tips about optimization and doing mobile development littered throughout, but some of the topic coverage seems shallow at times and those wanting more depth will definitely have to go online.

Given the newness of the platform, I think this is a great starting point for most developers.

This is the book to get if you know nothing about Android. It teaches through several examples, namely sudoku and a spinning, textured, translucent cube example. It's about half the size of Professional Android Application Development (Wrox Programmer to Programmer) and because of that is more condensed and to-the-point. I would recommend this book over the Wrox one as a first/only Android book.

Chapter 1 dives right in and gets your environment set up and the classic "Hello Android!" application running on an emulator. Only after getting code running does it go into details about the Android framework. I like this approach because until you start getting your hands into some code, you can't really appreciate the high-level stuff much or at all.

The sudoku application is started in chapter 3 and is developed over subsequent chapters adding graphics, sound, a dialog box and persistent state. By the end of the book, you will have put together (if you followed the code examples) a pretty cool sudoku app.

The remaining chapters focus on what I believe are the key components to mobile applications. Chapter 5 goes over playing sound and video. Chapter 7 goes over connecting to the internet. Chapter 8 is about SQLite. Chapter 9 (my favorite) is a step-by-step 3D OpenGL graphics example of a spinning, textured, translucent cube.

Bottom Line: This book has excellent examples with explanations of what the code means that will get you started building Android apps quickly. I highly recommend this to anyone looking to buy a first Android book or interested specifically in graphics for Android.

This book was a huge help in my discovery of Android programming basics. I'm not even a Java programmer - which would have helped - but it wasn't necessary to get the tutorial code up and running.

There are plenty of reasonable, working examples. It is well written and easy to follow. Just enough humor to de-sanitize the technical discussion without being ridiculous.

I didn't have to root my phone for any of this study. In fact, you don't even NEED an Android device, if you use the author's example of using the Eclipse GUI and Android emulator. (PC/Mac/*nix)

My first Android app will be on the Market soon. That would not have happened without the valuable information found in Hello, Android.

This book does not cover everything, but it will get you familiar with the basics. After you're read the book and built all the samples you feel very comfortable going off with the reference documentation and figuring things out. You may want to accompany this with a wrox book if you're a paper person (i'm not).

If you're like me in that you do not have an inkling about programming, let alone Java, this book will stop you cold after chapter 3, page 60; the rest of the book is worth a scan through.

The author states in the beginning of the book that "the only requirement is a basic understanding of programming in Java or a similar object-oriented language". I don't have any programming experience so I was just hoping to learn some idea of what Android development was like. It felt like attending 1st grade before learning your ABCs.

However, thanks to the book, I feel I've taken the first step in having some idea now of how much time and effort needs to go into Android development. At the very least I was able:
1) setup the Android SDK and Eclipse environments
2) learn the concept and framework for developing Android
3) perform basic commands and create an actual "app".

Probably a good idea for the author is to include some book references in the beginning of the book for newbies like me. That's my next step. Once I get a better idea of programming and Java, I'll be back to finishing this book - I really want to create my own Sudouku game!

This has been great so far. I'm about half-way through it. It's done a great job thus far, very progressive..I feel like i'm making progress, anyways. And thanks to this book, I have a much better understanding of the way Android works. The example of a Sudoku app, and working through it from scratch has been a wonderful way to learn android. Book isn't for BEGINNERS. It does a decent job of speaking in plain english, instead of over-complicating like many programming books do. But some experience with programming concepts is going to help you through the book. If you've done any programming before, and want to get into mobile development..Heres your chance.

Burnette defines three or four challenges for each chapter.
Then he shows the solution.
But, he doesn't explain every line.

So, one is moved to hunt through the Andoid Developers site, or another source, until one learns all the details.
That worked for me.

Great book, the sudoku example is simple (to those who know some programming) and helpful, it got me motivated on building my first Android App.

This book is simply great ! it contains all you need to start developping for Android from the installation SDK to the written of a complex app. The presentation (chapters) is perfect with some little jokes of the author. I have even bought the corresponding e-book so I can continue to learn while on the go on my Android device.

Domi @ gosymbian.com

Guys, If you're new to Android programming - this is the book for you. I'm a C# developer never touched Java and I feel programming Android is so easy with this extraordinary book. I read the book from cover to cover and Above all I like the elegance of the writing style - not hundreds of pages stuffed with raw code lines but rather clear explanations with small code fragments. The book covers a lot of cool topics from the very basic to more advanced. After finishing this book you will be able to program almost every Android application and be in a good position to delve into the most advanced levels.
So far I bought about 50 books from Amazon (C++, C#, DirectX, Flash, 3ds Max, Design patterns and more..) - this book is one of the very best!

This is the third of a beginning text on developing for the Android platform. It includes updated instructions on dealing with versions 1.5 through 2.2.

The book is written for beginning programmers, though some experience in Java is useful. There are some differences between Java and Android programming environment, and the experienced Java programmer will have to make some adjustments to effectively use Android.

The book starts with the usual "Hello World" program, and adds a short puzzle implementation of Sudoku. It goes on to teach dealing with audio and video, then storing information locally. SQLite and OpenGL graphics are introduced, and the programming portion ends with a discussion of multi-touch in its current implementation on Android. Final chapters deal with debugging and program publishing in the Android Market.

A helpful feature of the book is the presence of a "fast forward" section at the end of each chapter. It gives further references and suggestions to enhance your understanding of the material presented in the chapter.

All in all, this is a reasonable intro to programming in Android, and covers significant territory in spite of of being only 274 pages. In an OS that adds editions every 6-12 months, it is difficult to have a "current" resource. But this book will at least get you started, though you'll probably have to depend on other resources for the most up to date information.

The book is well supported, the code examples used in the book are available online, and there is a strong Android user community. Highly recommended for the beginning and early mid level programmer.

Pragmatic makes some computing books, and 'Hello, Android: Introducing Google's Mobile Development Platform' is more of the same goodness that is to be expected from this line. I really like this book a lot. The writing is very easy to follow and the book hits the sweet spot of 250-300 pages that should be the goal for nearly any book that is written. Not too long, not to short, but juuust right. 14 chapters of content are what is in store for the reader, covering the basics to UI to multimedia to database work to... lets just say there is a lot of good stuff here!!

There aren't a lot of books about Android on the market, so as a new developer you owe it to yourself to read them all, and there is a reason this is now in its 3rd Edition. I wish the book had some color as this is a personal sticking point for me with ALL books, but I rarely fault the publishers and I won't fault them here.

Great book for all!!

***** RECOMMENDED

I am in Chapter 3 of this book and I have learned a lot so far. I have tried a few other books, but this book (third edition) has been the best so far.

Besides having the code available on a website, the author explains concepts with concrete examples. Other books cover these same topics, but Hello, Android has step-by-step examples, building an application from the start.

Ed Burnette's book "Hello, Android" (HA) has been a popular choice for many Android "noobs". It is an interesting starter book like the title indicates, "hello". It covers all the areas relevant to building an application. Like designing forms, data binding, SQL, some graphics and deployment to market. But what you won't get is a detailed analysis and explanation of the structure of applications and the API.

So, HA is an intermediate developers book with java experience. I did find it a little frustrating at times that there was not much detailed explanation of the code. Ed ramps up the complexity by chapter 4 considerably. You have to plough through code without much explanation at all. So, although I understand his intent, increasing the complexity so rapidly is not really the best way to go in my opinion. I managed to get through the code myself, and I am not java guru, so it is possible. I suppose he is trying to produce something engaging at the end.

Seeing as Ed doesn't provide much detail, perhaps he should have chosen a less complex sample to help introduce the reader. Bit of an oxymoron, as it's supposed to be an introduction to Android, but the complexity is quite high which could distract from the high level concepts he is trying to convey. It seems that Ed is taking you through the process and broad structures, more than dealing with the detail of the code.

You will have to use online resources to research specific classes and their respective API's if you really want to get indepth knowledge about it. After all the book is only 270-ish pages long. You can easily finish it in a week of evening hacking. The online download of the code I found a little frustrating as it's not structured in a way that is easy to install whilst going through the book. I think it would have been more helpful to provide the code versions according to chapters, (chptr02/src, chptr03/src) etc. Because if there is not much explanation and you get a "force close" sometimes you just want to get the working code and move on.

The other aspect of this book is that you need to follow the entire book. You can't just open it up and start coding from any point. Again, this is not such an issue as the book is not that long. I would recommend that you follow the book, don't skip stuff or you will come un-stuck.

HA is good if you just want some instruction on putting something together to see it run in the emulator. Ed shows a good way to structure your application and you should be able to adapt it to your own needs. An experienced developer can start to put things together conceptually themselves, there is no spoon feeding here. I would have appreciated a little more explanation of detail, or a less complex example to build. However, with some perseverance, I found by the end of the book I understood the structure of android applications and can take it further through other reading/experience. So Ed has accomplished his goal by empowering the reader by introducing Android to you.

I recommend it if you just want to dive in and not be too concerned with light explanations.

I would then recommend Professional Android 2 Application Development (Wrox Programmer to Programmer) after this one for heavier reading, and you will get through it faster by going via Ed's book first.

You can figure things out for yourself but the book does leave some things a little fuzzy. Maybe try the electronic version with updates. The printed version is no good....m

I bought this book few days ago based on numerous positive reviews. First 3 chapters were good. Fourth chaper is a long listing of code without much explanation or background. Subsequent chapers seem to follow same style.

I am a senior programmer in C# and know Java.

I am now looking into other books. Unless you can understand code without much help this book is not for you.

This book was exactly what I needed to create my first Android application. I received this book on June 7th, 2011. Last night July 23rd, I uploaded my first app to the Android Market.

During this time my wife was hospitalized and I still worked on my main Windows application so my Droid program was part time. That's still 47 days from project start with no Android knowledge to having an app, DroidPatrol now on sale for $1.99. I never expected my first release to be so quick and I owe it to the way this book was prepared and written.

Obviously, I recommend the purchase of this book.

Bill Pytlovany
BillP Studios

This was a great beginners resource. Knowledge of Java (or C language) is expected, but it gives you the foundation needed to create nice GUIs utilizing the XML features of Android.

This is an excellent book that delivers exactly what it promises -- an introduction to the Android platform. Reading this book, I was able to get an application up and running leveraging many of the most frequently used elements in the API. This book is a very good first step in getting familiar with the platform and making real progress.

This book is probably not for the beginning programmer, and whether or not its even for the beginning JAVA programmer might be debatable. If you're new to Java, but familiar with object oriented principles, you're probably in good shape. If both Java and Object Oriented Programming or foreign to you, you might be better served getting a primer on Java before you start reading this book. Of course, if you're an experienced Java programmer, you'll fly through this book with no problem.

Once you get up to speed with the Android API and have been able to write some basic applications, you'll definitely want to explore the API beyond what this book will teach you, and there are many other really great books to choose from when you're ready. Until then, you'll be very happy with this title.

I've found this an excellent introduction to Android for someone who already knows Java. Specifically, I've found the chapters building up a Sudoku application to be very useful. The classes and methods are clear, and the author generally provides the right amount of commentary. In the few cases where something isn't clear, one can go to the forum, where the author quickly responds to questions, making the book even more valuable. All of the code is available online, which I've found useful as well.

I have some quibbles with the programming style, such as the embedding of magic numbers, but these are minor. Potential buyers should be aware that this is not a complete guide to Android. For example, there is very little about concurrency, with no mention of AsyncTask, for example. Still, I would recommend it as a very reasonably priced, well written, first book on Android.

If you are heading into Java/Android for the first time don't expect to understand everything in the book on the first read. I have done Java programming and Android is a twist on it. The book starts off building a soduko game then manages to drift off into UI development and other tasks not related to the game. I read the book cover to cover without writing any code the first time through. The book covers a broad range of topics without getting to deep into them. My suggestion is to read the book completely then go back through and create the code. It will help in the end while you build the game on your second time through. Very good read in my opinion.

You can get through the book in a weekend. I took a couple of cross-country flights, read the book on the way there and on the way back. After getting home, had my first android app running within an afternoon. The book won't be the end of your journey on figuring out how to do things, but it's a tremendously good place to start.

The book is introductory, really. It merely touches on a lot of areas. If you get serious about developing on Android, you'll need to do a lot more research. But the book is designed to just get you started, and hold your hand over the hardest part: getting basic control of what you're doing and getting started. It does this wonderfully, and so for that I give it 5 stars.

This is for version 1.5, and today we're at version 2.2. I wouldn't worry about this too much. This book is all about getting you up and running quickly, and it does that. It will give you what you need to get running and figure out for yourself what's different in later versions. Also keep in mind that many devices out there are still on version 1.5 (for a while longer anyway), so you may want to be developing back to this version anyway.

If you expect it to be the last book you'll ever need and your one stop shop for all things Android, you'll be disappointed. But to do that, the book would have to be overwhelmingly large. So get this book and take it for what it is: the perfect way to get started with developing on Android.

The title basically says it all. I picked up this book for work to catch up on Android since we had a few projects dealing with it. Overall it's a great way to start teaching yourself, but it tries to force the xml way of handling all of your ui elements and resources, which was not a feasible option for our projects. This limited the book's usefulness for me, but I continued on and found it entirely readable, easy to follow, and I suspect for someone working on a purely android project a lot of useful information would be found in the book, but I think most professional programmers won't like this approach.

I rated this four stars for:
* easiness to read (doesn't bore you to sleep!)
* straight forward examples
* useful jumping off point.
Downsides were:
* it's scope (limited to a particular way of doing things, mostly)
* it's breadth (doesn't cover all the topics you want, just the big points).

I would cautiously recommend this book. Probably more of a 3.5 star book, but I gave it the benefit of the doubt. If you don't know anything about mobile development and are having a hard time working through the android example on google's dev site (or have completed it and want to know what's next), this might be a good book for you. If you're a seasoned professional, probably best to look/wait for another book or just start trying things out (and check out the SDK).

I had previously given it a two and have included that review below. But getting deeper I'm finding so much missing. The book walks you through the steps of making A Sudoku application, but excludes major portions which are in the online sample code. But including that code causes a whole bunch of reference errors to a point at which you end up copying everything from the example. Not much is explained except for the walk-through (see below) so it ends up making the book pretty useless.

Prior:
It walks you through the process of building an application and subsequently you run into a portion of the SDK but it explains little in terms of why you are doing what you are doing. I feel very much like I'm following a recipe. Perhaps the idea is that you can further research using the Android online reference, but in that case I don't really need the book in that Android's developer website offers a bunch of online tutorials and examples.

It'd been a while since I needed an introduction to Android. I remember I skimmed over a few articles and blog entries, but thought a book would provide me an organized learning approach. When I inquired about a Android book for novices on my blog, a reader pointed out "Hello, Android" (3rd edition) by Ed Burnette from the Pragmatic Programmers. I asked for a review copy of the book and got it.

I was reading Version: P7.0 (July 2011) using Amazon Kindle for Android on Samsung Galaxy S2. It was my first book read this way and either the smartphone, Amazon Kindle, the quality of the mobile version of the book, its content or all of them together made it a very pleasant experience. I was surprised to find that reading an ebook might be such a fruitful activity (no pun intended). Thanks the Pragmatic Programmers for having encouraged me to try it out.

The author strove for high accuracy and simplicity to teach readers developing Android applications with ease. He spared no effort to turn your learning endeavor into an easy and engaging one. It didn't take long before I immersed myself in reading the book.

The book lays the solid foundations of effective Android learning. It provides material that exceeds a mere introduction to the platform and I believe it touches every major feature of Android, up to the version 2.2. 300 pages, 5 parts and many chapters with a summary in Fast-Forward sections were all I really needed as a starter. With no doubt I can suggest it to anyone to learn the platform. The writing style is simply unbeatable - I hardly resisted longer reading, but alas it's not uncommon to run into "these are beyond the scope of this book, but if you need them for your program, consult the online documentation." When I first ran into it, I was quite surprised, even angry, but the more I hit it, the easier it was to explain its reasons - the book would otherwise have been very long and lost its beauty being slim and easy to read in one go. The book encourages using other resources instead like the book's web forum or the Android official documentation. It worked fine for me.

The book aims at sharing a bit more than it's really necessary to learn Android. I always enjoy learning a little more as a bonus. There are notes like "Thank you, John Carmack" about OpenGL's history or Sudoku Trivia, which some may argue against in a book about Android. They may distract quite easily, but I found it very mind-refreshing as a kind of a break from continuously reading about Android itself. I believe it was more helpful than damaging.

I seem to have missed a little explanation here and there, like in "in the current versions of ADT, the visual layout editor isn't that useful" (page 48), but in no way could it diminish its final note - you must read the book if you need to grasp the concepts of Android development easily and without wasting time. I doubt if there's a book that does it better (however I wish to be told I'm wrong). Such a snappy book for seamlessly getting along with Android like "Hello, Android (3rd edition)" is no simple task to beat out.

If I had to point out the book's shortcomings, it would certainly be its paying attention to explaining how the throws keyword and RuntimeException work in Java (page 186). I'd call it a slight hiccup, though. It was simply odd to stumble upon it in a book about Android where Java is supposed to be learnt already.

There are quite a few complete Android applications to accompany your learning with this book. Developing them follows well-thought-out path from a simple activity and view into more complex ones. Once you're into it, which doesn't take long, the book inevitably ends. I wish it had been longer or there were its second, more advanced version.

It provided me the best foundation for beginning to write Android applications. I was just evaluating whether I should even start on this journey and I am glad this book didn't scare me away. The book explains only the very basic concepts but those are enough to get started. For the rest, Google Android API documentation is enough.
I still sometimes go back to this book to refresh some basic concepts but in general, once you have published an application, you wouldn't need this book again.

I am a begginer with the android development but not with java nor java embedded programming, and i found this book quite useful because it is kind a tutorial but with the exact amount of theorical information.

If you are the kind of people who love code before anything else, this book is for you.

I know this book will help me in future as quick reference so it is a plus.

I try to keep in touch with coding skills every now and then..
Recently I tried my skills at Android coding and this book was real handy.
It walks you through a real example providing enough details to get up and running quickly.
Its a good idea to complement this with the Google Android development page - that gives you the theory while this book tells you how to plug into the framework quickly.
CAUTION/Prerequisite - you need to know Java and XML.

I like books based on full projects. That allows to see how things work together. That was the case with the Sudoku app. I hope the author will write another book (or even better, other books) based on another type of app (productivity apps, games, etc).

This is the book to read if you want a quick tutorial on Android programming. Got my own app up and running withing a week of reading it. You only need to read the first 100 pages to get the hang of it. The rest of the book offers some additional topics that you can pick and choose from as needed by your app. Some simple programming concepts are a prerequisite though, such as classes, switch statements, for looops and the basics of OOP.

I was trying to learn Android on my own and was getting very frustrated. The day this book arrived I worked through the first three chapters and have the Sudoku tutorial game half finished. Be advised, however, that getting that far took me over three hours and I already had the Android development environment working under Netbeans when I started.

If you are thinking of learning Android, the first thing you need to do is learn Java. Not Javascript, real Java. And you need to learn it well. You also need to learn some XML. I was surprised to see how much XML Android uses.

It is true that the author has a few mistakes in his sample code, but if you are not ready to deal with debugging and fixing mistakes, then your are not ready for programming in any language or environment.

I found this to be a nicely organized, well explained, tutorial on Android software
development. The coding examples displayed many of the important concepts. The
projects imported easily into Eclipse thus making them easy to experiment with.

I found this book easy to follow, especially since I'm a newbie to Android programming. I would recommend it to anyone starting out, the author does a great job at explaining the reasoning behind a lot of the coding. Enjoy!

This book suffers from one major flaw: it slings code at you without bothering to explain what the code does. A good example of this is the main layout screen for sudoko in chapter 2. The author tells you that there are a few different layout containers that determine how user interface elements are laid out, and even goes so far as to give a basic run down of how each container places objects contained within them, which is nice, but then just slings a section of code at you that represents your main screen layout, without any further explanation as to what any of things you're typing actually mean. Another example is the settings menu example. It gets to the point where everything is just here type this and this is what happens.

The nice thing about the book is that you go from a to z in the creation of a complete game, but you're really going to need to keep the api docs and dev guide from [...] open so that you can use them to decipher what the author has you doing.

Don't go near this book unless you are comfortable reading api docs.

I'd been picking up Java on the side and a friend recommended this book to me when I mentioned an interest in Android apps. This has been a good book. Easy to read, easy to follow. I have a strong background in C and a few other programming languages from my time as a software developer and this has been a nice addition to my library. It's also a good reference to the Google Android docs/sites and to the various user groups. I would recommend this book. If only Kernighan and Ritchie had written "The C Programming Language" like Mr Burnette wrote this one, the K & R book would have been a much more entertaining read. db

This book is easy to read and seems to be great for a beginner. However, to experienced programmers, this book is inefficient. It doesn't provide a big view of Android framework and SDK effectively.

HELLO, ANDROID: INTRODUCING GOOGLE'S MOBILE DEVELOPMENT PLATFORM covers all the basics of creating working applications using Android, which blends cell phones, open source software, and Google and other Open Alliance members. It's a mobile platform packed with options and applications, from building location- based services such as GPS to adding 2D and 3D graphics and networking with web services. Computer libraries will find it a top pick.

Perfect! And quicker than I expected.
I thought it was going to take at least a month and I got it in 17 days. Well done AMAZON.Hello, Android: Introducing Google's Mobile Development Platform (Pragmatic Programmers)