eldavojohn writes: Gartner's released a report on Worldwide numbers of 2012 3Q phone sales and the staggering results posted from Android have caused people like IW's Eric Zeman to call for sanity. Keep in mind these are worldwide numbers which might be less surprising when you realize that the biggest growth market of them all is China who is more than 90% Android. It's time to face the facts and realize that Android now owns 73% of the worldwide smartphone market. While developers bicker over which platform is best for development and earnings, the people of the world may be making the choice based on just how inexpensive an Android smartphone can be. This same time last year, Gartner reported Android at 52.5% of market share and it now sits at 72.4% market share with over 122 million units sold worldwide. Only Q4 reports will tell if Android's momentum will finally begin to slow to save some chance of competition in the smartphone ecosystem or if the Quickening will be complete.
eldavojohn writes: News outlets are reporting that AMD has partnered with BlueStacks to bring Android apps to AppZone Player, something that will apparently allow the more than 500,000 mobile apps to run on your PC. From their announcement: 'What’s special about the player on AMD-based products? There are many challenges with running apps that were originally designed for phones or tablets on a PC that in most cases has a larger screen and higher resolution display. To solve this, BlueStacks has designed and optimized the player for AMD Radeon graphics and in particular, our OpenGL drivers found in our APUs and GPUs so you get a great ‘big-screen’ experience. Additionally, the apps are integrated into AppZone, our online showcase and one-stop-shop for apps accelerated by AMD technology.' Unfortunately this appears to only work on AMD-based PCs (although nowhere does it say that it won't work on Intel CPUs or non-Radeon GPUs). Also no word on how they overcame the difference between a mouse and touchscreen (think pinch to zoom).
eldavojohn writes: A recent blog post has Android developers talking about Google finally scanning third party applications for malware. Oddly enough, Google claims this service (codenamed 'Bouncer') has been active for some time: 'The service has been looking for malicious apps in Market for a while now, and between the first and second halves of 2011, we saw a 40% decrease in the number of potentially-malicious downloads from Android Market. This drop occurred at the same time that companies who market and sell anti-malware and security software have been reporting that malicious applications are on the rise.' So it appears that they allow the software to be sold even before it is scanned and it also appears that no one has been bitten by a false positive from this software. Apparently Bouncer is not as oppressive as Apple's solution although given recent news its effectiveness must be questioned. Have any readers had their apps flagged or pulled by Bouncer?
eldavojohn writes: A staggering shift in the US between October of 2010 and January of 2011 (Android up 7.7%, Blackberry down 5.4%) indicates that Android has surpassed Blackberry in smart-phone platform market share. Other research puts it at 35% of worldwide total smart-phone market share. This presents reinforcing evidence for Android's new dominance in the smart-phone world. Is Android's lead over the business savvy Blackberry temporary or has it become a competitor for that market?
eldavojohn writes: "You're probably familiar with Microsoft's long runningassault on Android but, as noticed by Groklaw, Barnes and Noble has fired back saying, 'Microsoft has asserted patents that extend only to arbitrary, outmoded, or non-essential design features, but uses these patents to demand that every manufacturer of an Android-based mobile device take a license from Microsoft and pay exorbitant licensing fees or face protracted and expensive patent infringement litigation.' Barnes and Noble goes on to assert that Microsoft violates 'antitrust laws, threatens competition for mobile device operating systems and is further evidence of Microsoft’s efforts to dominate and control Android and other open source operating systems.' The PDF of the filing from two days ago is rife with accusations including, 'Microsoft intends to utilize its patents to control the activities of and extract fees from the designers, developers, and manufacturers of devices, including tablets, eReaders, and other mobile devices, that employ the Android Operating System.' and 'Microsoft has falsely and without justification asserted that its patents somehow provide it with the right to prohibit device manufacturers from employing new versions of the Android Operating System, or third party software.' Barnes and Noble does not mince words when explaining Microsoft's FUD campaign to both the public and developers in its attempts to suppress Android. It's good to see PJ still digging through massive court briefs to bring us the details on IP court battles."
eldavojohn writes: Riding the tail of Apple's 30% announcement, Google's Eric Schmidt has announced One Pass, a new method for users to pay for content. The BBC is reporting that Google is taking a 10% cut. One Pass will work on Google sites and on phones and tablets as the announcement notes: 'Readers who purchase from a One Pass publisher can access their content on tablets, smartphones and websites using a single sign-on with an email and password. Importantly, the service helps publishers authenticate existing subscribers so that readers don't have to re-subscribe in order to access their content on new devices.' This is to be handled through Google Checkout.
eldavojohn writes: The third edition of Hello, Android brings the book up to date on Android versions from 1.5 to 2.2 (FroYo). The book is predominantly tied to the Eclipse editing environment with several pages devoted to screen shots of the IDE. As the title suggests, this book aims to give the user the equivalent of a "Hello, world!" application in Android and succeeds in doing that but doesn't take the reader much further. From creating a sudoku application with increasing support to dabbling in OpenGL ES, the book's prime audience are people who know a little Java (with no aversion to Eclipse) and XML but absolutely no Android. You can find the source for all the examples.
The first aspect of this book that jumps out at me is that it assumes the user is using Eclipse — even late in the book like on page 231, an entire page is a screenshot of the project creation wizard in Eclipse. While this might be helpful for initiates to Eclipse, it seemed like a bit of overkill at times when actions in Ecipse are revisited throughout the brief book. For example that same screenshot with different options checked can be found engulfing page 10. "If you don't want to use Eclipse (there's one in every crowd)" says the author on page 4 before referring the reader to Android's command line reference. It gets to the point that when Burnette is going to sign his app at the end, he uses an Eclipse wizard.
The second aspect of this book that jumped out at me is that Android apps are written by extending Java classes and utilizing a very verbose XML. So between the overridden class methods and the layout meta data in the XML, there is a lot of code consuming vertical space in the book. Ellipses are provided to avoid redundancy in some instances but in others it seems there is no avoiding the space consumption. A strength of the book is that, when possible, it shows how to do something simple in both XML and Java and gives reasoning for picking a certain way the rest of the book.
The chapters are laid out with brief introductions and "Fast-Forwards" at the end of each chapter that try to push the user past this Hello, Android introduction to complex concepts. The book is well divided with part one (chapters 1 and 2) providing instructions for setting up your emulator and the basics of Android like a state transition diagram showing how all Android applications transition through Java methods in a life cycle. Part two (chapters 3 through 6) builds the sudoku application with increasing support. Part three (chapters 7 through 10) focus on more complex aspects of Android like device sensors, SQLite and OpenGL. The fourth and final section delves into the future of multi-touch on Android, writing for all resolutions and devices as well as publishing to the Android Market. Throughout the book the author takes care to to mention when you will need to put in a permissions requirement in the manifest file when utilizing something on the device.
In creating the sudoku application, Burnette does a good job at introducing the reader to some basic concepts like procedural designing versus declarative designing and Dips versus Sps. The author introduces the automatically managed R.java file and the first extension of android.app.Activity with a good explanation of how we're going to add menus from XML strings. This chapter nicely sets up the sudoku game to have an opening screen, a settings menu, a theme and exiting the game. It is lengthy but introduces the reader to click listeners as well as explicit information about how to debug. Android 2.2 adds a cute debug level of Log.wtf() which stands for "What a Terrible Failure."
Following that chapter, the author delves into some basic two dimensional graphical capabilities involving extending View in order to manipulate the canvas object inside onDraw. The chapter sums up drawables and gives a short example of text in a circle before returning to the graphics in our sudoku application. Burnette shows explicitly how to draw the game board and give it a nice embossed effect, how to add and center numbers in each of their cells, how to override key events to bring up an input screen with only valid numbers and how to continuously update the game screen. The chapter even goes as far as showing you how to shade the squares in order to give hints to the user. One thing I did not care for in this chapter (and something that persists through the rest of the book) is that the author has no qualms with calling a method in code (like calculateUsedTiles on page 68) and not defining what it does or how it works until the end of the chapter twenty pages later. Given that its signature is descriptive and it's not key to understanding Android, it's probably the best way to teach but left me doing a lot of page flipping since I like understanding apps from the bottom up. Something else to note about this chapter is that the author mentions on page 70 that he experienced "many false starts" of trying different approaches like multiple ImageView classes in XML before finding the fastest and easiest way of having only one view. There's just a couple paragraphs on this in a side box but I really wish the author had expanded on this as it sounds like a vital part of the learning Android process.
What good is a phone app without some sound? Chapter five covers Android's MediaPlayer which Burnette calls "a fickle beast" although it improves with each release of Android. The chapter also touches on playing video in Android which takes just a few lines of code. The author helps the reader by continually explaining what happens in Android when the device is rotated (in these examples the video restarts since the app is recreated). He explains how to avoid this several different ways. He also discusses why using a background service for music isn't a great idea if you intend the music to end when your program ends. By the end of the chapter, you've got some music for your sudoku app.
The next chapter very briefly covers local data storage. This is not the SQLite chapter but rather the PreferenceActivity API as well as the instance state stored via the Bundle in Android's application stack. The author doesn't spend a lot of time on these and wraps the chapter up with a brief description of accessing the internal file system as well as an external SD card.
Chapter eight covers GPS and other sensors your device might have that are supported through the latest Android API. The author takes care to understand how you need to setup your emulator if you are testing this on your computer and discusses listening for updates from sensors as well as interpreting that data. Unsurprisingly, the Android API has a MapActivity class to extend for applications that wish to impose data onto a map. I feel the author could have spent more time on the more novel sensor types that are becoming prevalent in cell phones but the GPS and maps might be adequate for an introductory book.
The ninth chapter is an introduction to SQLite in Android. Android supports other data storage solutions like db4o but the author sticks to SQLite and covers all SQL relational database aspects up to a simple cursor. It's done very well and anyone with a little knowledge of SQL should be able to create, modify and update tables inside Android applications with this chapter. A very interesting thing about this chapter is that it covers how to implement inter-process communication by way of a content provider. Android utilizes URIs that programmers can define to provide a framework for storage. The book is mediocre at describing both SQLite and ContentProviders in this chapter although I felt like the ContentProvider has enough material to deserve its own chapter — even in an introductory book. I personally feel it would be interesting to consider a chapter devoted to defining a content provider with reuse by a community intended. We get an EVENTS and EVENTS_ID example but I feel this falls short of the real beauty of ContentProviders.
The next chapter is a venture into three dimensional graphics in OpenGL ES (embedded systems). Twenty pages isn't a lot of space to work with when you're discussing OpenGL but this is a good basic introduction that leaves the reader with the means to do very basic OpenGL. The chapter starts off with some good fundamentals but also carefully explains that your devices might not have 3D hardware. The API is still there but the lag might be intolerable. The author thanks John Carmack for "single-handedly" saving us from Direct3D and starts off on the very verbose code of OpenGL. In it, there are great explanations on some basic options like ambient, diffuse and specular lighting as well as discussions of fixed versus floating point. Several pages later we have a transparent rotating cube with an Android image for a surface.
Chapter eleven is devoted to the buggiest part of Android: multi-touch. A side note titled "Warning: Multi-bugs Ahead" warns the reader about how problematic the following code is going to be and how it might perform differently on different quality of hardware. As Burnette builds out the image viewing application it's a lot of similar code to view an image with the new stuff revolving around debugging logs to give the reader key insight into how the author's phone interpreted his multi-touch interactions. Dragging and pinching are covered to zoom and move the image in the viewer and seems simple enough with the exception of bugs.
Twelve will show you how to build widgets and implement live wallpapers. To a lot of developers this chapter might be a turn off but to a lot of people looking to make money with Android, this seemed like the fastest route. The example just displays a semi-transparent "Hello World!" string but it is then demonstrated how an overriding the update allows you to put date or whatever else you might need to display. The live wallpaper seemed to me like the perfect way to drain the battery on a phone. Although more complicated than the widget, the chapter covers extending the Engine class to provide a drawing engine that will redraw the background — even with our OpenGL code from a previous chapter that the author then implements. The author really goes the distance on the live wallpaper, even explaining how to extend the surface of your wallpaper so that when you transition to another part of your space it slides the rotating cube. For better or for worse, you too can have a continuous rendering of OpenGL code for your home screen!
Chapter thirteen addresses the "fragmentation" issue that so many people have been criticizing Android for. It discusses declaring and demanding an API version as well as building different emulators out on your computer in order to run your application (although earlier in the book, the author heavily criticized the emulator as being terribly slow compared to the real hardware and I experienced the same thing with my Motorolla DROID). The author does a great job of discussing the unfortunately lengthy and complicated process of preparing your software for all hardware. From subclassing to reflection to delegation/factory, he analyzes each one and explains the strengths and weaknesses. If you're having problems with your application across hardware, this chapter is a great starting point. In the next piece of this chapter, the author calls out the Android API on a bug in the ImageView class that prevents the setImageMatrix from working in some cases (this is from 1.5 and has since been fixed). For those of you who are seriously dependent on Android, the author describes in detail his five steps in discovering and addressing this bug with the final step being a peak at the commit comments to the source tree. It's good to see an author doing legwork like this and telling the story but it's also a little unnerving to see the bug. Nevertheless, I applaud the author on this frank discussion. The final parts of this chapter are spent addressing screen size (an increasing issue with tablets) and installation by way of the SD card (something that can be auto or preferred).
The final chapter addresses publishing to the Android market and provides some actually really good insight into how one should approach this and how to interact with your user community. I'd like to note a couple things that the author lists as lessons learned. The first I found interesting was "you can make a paid app free, but you can't make a free app paid." What that means is if you publish something as free and then you update the app to move a piece of what was one free functionality to requiring payment, the backlash might destroy your app's user base. The other thing is something I flat out don't agree with: "If possible, I suggest you perform frequent updates, every two weeks or so." He claims it makes users happy and gives them a feeling of support as well as bumping it up to the top of the recently updated apps in the Market. I personally find it annoying and if I have an app that I use infrequently that frequently requests updates, I uninstall it. Case in point for me is TuneWiki Social Media Player. It seemed every other week that app was requiring an update and since I used it seldom, it was promptly uninstalled. I don't know if I'm alone in this sentiment but I found this chapter to be very insightful with the exception to that suggestion.
The appendices of this book were actually fairly interesting. I didn't know what the subset of the current Android app was for the Java Standard Edition 5.0 library. You can find a list of packages that will be unavailable to you like much of javax. The author also gives great pointers like try to avoid the expensive reflection no matter how elegant it might be for you.
This book is well written with only a few minor editing mistakes. It has a lot of illustrations which are often Eclipse screen shots. While some aspects of this book might alienate a few users, it is a great learning tool for its intended audience. I found it to be "okay" for my needs but perhaps was geared a bit more towards a more novice programmer.
eldavojohn writes: In a recent earnings call (their first $20 billion quarter), Steve Jobs took a few jabs at Android and how "open" it really is (audio here). He referred to the recent fragmentation issues cited by TweetDeck and said 'Google loves to characterize Android as open and iOS and iPhone as closed. We find that a bit disingenuous and clouding the difference between our approaches.' He went on to call the 'closed' vs 'open' debate nothing more than a 'smokescreen' for what is truly best for the customer. Google's Andy Rubin had a single Twitter post as a rebuttal: 'the definition of open: "mkdir android ; cd android ; repo init -u git://android.git.kernel.org/platform/manifest.git ; repo sync ; make"' Which, if you're familiar with git and make commands, will retrieve and build Android for your own modification and use.
eldavojohn writes: After developing and using TaintDroid, several universities found that of 30 popular free Android apps, half were sharing GPS data and phone numbers with advertisers and remote servers. A few months ago, one app was sending phone numbers to a remote server in China but today the situation looks a lot more prevasive. In their paper (PDF), the researchers blasted Google saying 'Android's coarse grained access control provides insufficient protection against third-party applications seeking to collect sensitive data.' Google's response: 'Android has taken steps to inform users of this trust relationship and to limit the amount of trust a user must grant to any given application developer. We also provide developers with best practices about how to handle user data. We consistently advise users to only install apps they trust.'
eldavojohn writes: According to AfterDawn, Google has given app makers the option to use a license server as DRM to ensure the user has paid for an app before they can download it. The report is that the market app will communicate with a Google license server using RSA encryption. It is important to note this is only available for non-free apps (built with SDK 1.5 and later) and it is instituted to provide a better solution to the old and widely criticized copy protection scheme that was criticized as susceptible to Android app piracy (like sideloading). For better or for worse, Android's Marketplace appears to now have an optional phone-home form of DRM.
eldavojohn writes: If you think the iPhone app store is the only mobile game store suffering an exodus, some game publishers claim Android's app store isn't much better at generating revenue. In fact, French game developer Gameloft (that owes 13% of its profits to iPhone game sales) said, 'We have significantly cut our investment in Android platform, just like... many others. It is not as neatly done as on the iPhone. Google has not been very good to entice customers to actually buy products. On Android nobody is making significant revenue. We are selling 400 times more games on iPhone than on Android." So the trade seems to be more sales but an annoying approval process versus a lack of sales promotions and no annoying approval process. It seems those in it for money will opt for iPhone and those in it for distribution will opt for Android or maybe someone will get it right one of these days?