Author: Bill Phillips, Chris Stewart, Brian Hardy and Kristin Marsicano
Publisher: Big Nerd Ranch Guides
Audience: Java programmers
Reviewer: Mike James
The Big Nerd Ranch Guide to Android is back with a second edition and now covers Android Studio and Lollipop.
It still covers the material used in the Big Nerd ranch Boot Camps and it is a very big book so don't expect to get it read in a short time.
It starts off nice and slow, but you will have to be able to program in Java to get anywhere with it. This is fairly universal for books on Android - there is just too much to cover to teach the language as well.
The first chapter gets you started with Android Studio. You learn about the very basics of Android by implementing a simple example - a quiz app. Although the book makes use of Android Studio it gets you to type in long XML listings to define the UI. This is not the best way to use Android Studio. Overall you get the impression that the conversion to Android Studio from the Eclipse based first edition hasn't gone very deep.
Chapter 2 introduces an MVC model for Android construction but don't be put off - this isn't theoretical. Even so the detour into an unnecessary topic when the reader is trying to master Android programming isn't really helpful. There are those who are of the opinion that MVC is so basic is should be what is taught from the very beginning even if it does complicate things - I don't agree. Then we cover the activity lifecycle, debugging and adding a second activity.
Chapter 6 looks at the problems of managing so many SDK versions. Chapter 7 opens up the difficult topic of fragments which is a bit strange because it comes before a treatment of the UI Widgets in Chapter 8. Again this seems unnecessarily cruel to the beginner. Much better to deal with a non-Fragment based UI and then deal with this difficult topic later. The final part of the chapter outlines the arguments for not using Fragments until you actually need them or always using Fragments. The final verdict is to always use Fragments, a sentiment I mostly agree with but this doesn't mean you have to introduce them to the beginner so early.
The next few chapters - up to chapter 14 are all about the UI including dialog boxes, the action bar and so on. The Android Studio designer is used. Later chapters in this section concentrate on using Fragment oriented UI elements such as ViewPager and a Fragment approach to dialogs. Chapter 14 takes us on a small detour to look at SQLite; then Chapter 15 introduces the idea of implicit intents so that you can find out how to take a photo in Chapter 16. Then we move back to the UI and look at the system of assets and resources.
Chapter 19 takes us into the world of audio playback only to move to styles and themes in Chapter 20 and XML drawables in Chapter 21. The logic that is driving this seemly random walk through of topics is the example introduced in Chapter 19 - a beatbox app. This is why we return to Intents and introduce tasks in Chapter 22.
Chapter 23 introduces networking with HTTP, 24 is on threading, 25 is about search, 26 is on background services and 27 is on broadcast intents. This is a strange mix of very basic things you need to know early and increasingly advanced material. Next we jump back a level to look at using WebView and then up a level to look at custom views and gestures before jumping down a level to animation.
The final few chapters continue to jump around - 31 location, 32 maps, and 33 is on material design and brings the book to a close.
You can tell that the book covers a lot of ground in its 600 or so pages. However, each chapter is short and as the book progresses the level of explanation starts to decrease. The order that the topics are introduced in is very much driven by the examples that are used. This is fine when you are reading the book chapter by chapter, but less satisfactory if you need to find out about a topic and jump into the middle of something.
There is also a mix of the very basic and the more advanced - the advanced ideas are needed to get the example project progressed but if a simpler example had been chosen then the advanced ideas could have been kept for later.
As long as you are a smart programmer this shouldn't be too much of a problem but if you really are a beginner then you are likely to find it overwhelming. To be honest Android is a bit overwhelming and it is a big and complex programming environment which this book documents but does little to make seem easier or simpler.
As long as you know Java reasonably well and are prepared not to be put off by the mix of levels this is a good place to start an exploration of Android programming.