Android Tips: Generating a coverage report for your unit tests

The Android testing framework has the built-in ability to generate a code coverage report for your unit tests. Unfortunately this functionality is not available within the Eclipse IDE, so you have to resort to some command line and Ant fu.

First off, you need to create a test project for your Android app and some unit tests.

Next, run the following command:

android update test-project -m <path to app project> -p <path to test project>

This will create a Ant build.xml file in your test project’s top-level directory. The android tool can be found in the tools folder of your SDK installation.

Now, from your test projects top-level directory, run the following command:

ant coverage

This will build, instrument, deploy and run your unit tests. It will also generate a HTML coverage report.

The location of the report will be displayed in the last few lines of the Ant script’s output. Point a web browser at the coverage report and weep :)

UPDATE: if you are using SDK 14 or later then the command to run is now:

ant emma debug install test

See the SDK Ant command reference for more details

ScanPaste – My first app released to the Android Market

Last week I released by first Android application on the Android Market. It is called ScanPaste. The application lets you scan barcodes and then  copy the scanned data to the phone’s clipboard for pasting into web pages, emails etc.

I had been looking for a simple app to build, to test out the end to end Android Market publishing process and when I saw this blog post by about populating your Google books list using barcodes scanned with a USB scanner, I figured why not build an Android app to do it.

Now scanning barcodes with a phone’s camera is not that simple but luckily someone else has done all the hard work. The ZXing team have released an excellent barcode scanning application and library. Even better, using a cool feature of Android, integrating barcode scanning into ScanPaste was only a few lines of code!

In an Android application each screen is broken down into it’s own little task called an Activity. If an Activity is correctly “marked” it can be initiated not only by the application owning the Activity but by other applications. This is what the nice guys on the ZXing team have done and with their application installed, any other application can simply use the following code to scan and process barcodes:

// start the scan
Intent intent = new Intent("");
startActivityForResult(intent, 0);
public void onActivityResult(int requestCode, int resultCode, Intent data)
  if (resultCode == Activity.RESULT_OK && requestCode == 0)
    Bundle extras = data.getExtras();
    String result = extras.getString("SCAN_RESULT");
    // do stuff with result here

The rest of the app is pretty straightforward, a couple of buttons, a text field and some error checking. All up the application is less than 100 lines of code.

In all it took a few hours to put together and test. The bulk of the time was actually spent working on the icon :) The 1.5 Android platform has some pretty clear guidelines and I was trying to adher to them.

Building a signed app for upload to the Market was a snap, just a menu click and a step by step wizard. Actually publishing the application was as simple as uploading the signed .apk file, filling in a form and clicking on upload. Couldn’t be simpler especially when you compare it to the nightmare process of uploading an iPhone app to the iPhone App store and of course the Android Market doesn’t have a vetting process so as soon as the upload was complete the application could be downloaded by anyone.

One of the things that took me by surprise was that within half an hour the application had been downloaded 20 times. A week later it has been downloaded 1849 times and it has 1156 active installs! It also has a 4 12 star rating and all positive comments. From the comments it seems that many people are using the app to scan the barcodes of books that they are selling on Amazon.

Ok the bad stuff….

Firstly, a minor one,  in the developer console of the Market there is no way to see the comments about your application. You can see the rating and the number of ratings but that is it. Instead you need to look up the app in the Market application on your phone or view a 3rd party site like Cyrket (which apparently uses the Market’s own APIs so why the info cannot be surfaced in the developer console is beyond me).

Now for the killer…since I am in New Zealand I cannot sell any Android applications! I need to be in the US, UK or one of a couple of other countries to be able to sign up as merchant. What the heck is up with that? I see that as a major shortcoming of the Android platform and one that Google needs to rectify ASAP.

Hopefully with the imminent launch of the HTC Magic here in New Zealand this will change. Lets wait and see….

G1 the first Google Android released

With heavy guitar music and much fanfare the first Google Android handset has been released by T-Mobile.

The device looks pretty nice (but not iPhone sexy) and has a ton of features. It will go on sale on the 22 October and retail for $179 US.

Initial reviews are mixed but I suspect that this New York Times article hits close to the truth:

“If the HTC’s new G1 cellphone, featuring Google’s Android software, were introduced two years ago, jaws would drop. But Apple’s iPhone already won the wows that go to the first small phone that is truly good at Web browsing.”


“my initial take is that the G1 is the PC to the iPhone’s Macintosh…“

Playing with the Android emulator I always suspected that that last quote would be true, still it will be interesting to see how it all goes on the 22nd.

Also released is the final 1.0 SDK and a hint that the beta Android Market will go live on the 22nd when the G1 goes on sale. Guess I’ll have to get cracking with finishing off Bubbles!

Update: Gizmoda has a very good hands on review of the G1 with lots of pictures and video. Check it out.

Android getting ready for launch

Well things seem to be heating up in the Android world…

First off the new version of the SDK (0.9) became available. The APIs have undergone some rather radical changes since m15 but apparently they should be mostly stable now. Its going to take some serious work to get Bubbles! up and running again.

Next all sorts of leaks about the first Android handset (the HTC Dream) starting popping up on the Internet. Gizmodo have some spy pictures of the phone, it looks good but not iPhone sexy. I think the slide out qwerty keyboard is a good idea but it doesn’t help the devices looks.

Google also posted some information about their content distribution system which will be the Android equivalent of the iPhone’s App Store.

“Developers will be able to make their content available on an open service hosted by Google that features a feedback and rating system similar to YouTube. We chose the term “market” rather than “store” because we feel that developers should have an open and unobstructed environment to make their content available. Similar to YouTube, content can debut in the marketplace after only three simple steps: register as a merchant, upload and describe your content and publish it.”

It certainly seems that getting an Android application out into the wild will be far easier (and less expensive) then an iPhone application.

And lastly, today the Android team posted the Android Developer Challenge Winners gallery showcasing the final 50 apps and the winning apps. Some pretty interesting application here.

Its going to be interesting to see how Android and the HTC Dream do against the iPhone tsunami.

Bubbles! now uses Google App Engine

Just for kicks I decided to port the backend services for my Google Android app, Bubbles!,  to use the Google App Engine.

For those of you who don’t know Googles App Engine is a “free” application hosting environment. It promises to be able to scale Google style (as long as you pay of course).

The free account gives you 500Mb of persistent storage and bandwidth and CPU for around 5million pages views a month which is not bad for free.


For some strange reason Python is the language of choice for app engine. I’ve never really taken to Python and I don’t really like languages where indentation is syntactically meaningful but it wasn’t too painful after skimming some tutorials on the web and running through the tutorial.


The SDK is only a couple of megabytes to download (you need Python 2.5 installed) and ran fine on my Windows XP desktop and Ubuntu laptop. Having said that the SDK doesn’t give you very much in the way of an IDE, it just gives you a dev web server and a tool to upload your application to the hosting platform. So I just used gedit and Notepad++ (which both have Python syntax highlighting) as my editors.

Platform Features

App Engine provides a pretty easy to use framework for building web applications in Python. The engine is WSGI compliant so you can plugin in any of the common Python frameworks such as Django, CherryPy, Pylons and Django seems to be the web app framework of choice.

Apart from a web application framework, the engine also provides APIs for email, image manipulation, URL fetching, users and datastorage.

The Users API is pretty cool as it hooks into Google’s user accounts so anyone with a Google account can log into your application (if you want them too).

The datastore is an object based transaction engine with a SQL like syntax. On the face of it is very clean and easy to use but its here that I had the biggest headaches when porting the Bubbles! services.


Porting the services**

Bubbles! uses 3 very simple services: popin, popout and getpops (where a POP is a point of presence). These services take input parameters from the query string and return JSON response strings.

Creating a class to represent a Pop in the datastore was very simple; as was creating and deleting Pops in the datastore. The biggest issue I had here was coming up with an elegant way of validating the input parameters.

But when I came to getting things back out of the datastore things went a little pear shaped…

In my Pop class I was storing the latitude and longitude of the POP as floating point numbers. To retrieve the nearby POPs (in the getpops service) I was using a typical SQL like query as follows:

SELECT * FROM POP<br /> WHERE lat >= :1 AND lat < :2 AND lng >= :3 AND lng < :4<br /> ORDER BY lastdatemodified

Where :1, :2, :3 and :4 were set to currentLat-0.001, currentLat+0.001, currentLng-0.001 and currentLng+0.001._


This raised the first issue: Only one “property” can have an inequality clause in a query. Turns out that the datastore has some pretty weird and wonderful restrictions, of course this particular one put a major spanner in the works.

Geohash to the rescue

What I needed was a quick way of calculating if a point in space was close to another one and to be honest the approach I was never happy with the approach I used above because it found points in rectangular area not a circular one.

After a little bit of research (I love the web), I came across this concept: the Geohash.

This cool (public domain) algorithm takes a decimal lat/long and turns it into a string. For instance

-36.843480 174.767138



Not only does this give you something that you can stick on a #aliases: but more importantly for points near to each other the first few characters of the hash are the same !

-36.843480 174.767138  =  rckq2uve1mx3<br /> -36.844381 174.765611  =  rckq2usmvvsd<br /> -36.848508 174.765451  =  rckq2gumfhjr<br /> -36.848457 174.748261  =  rckq27zy1tg8

So the solution to my problem turns out to be remarkably easy:

  1. When creating or updating a POP I calculate the Geohash for the longitude and latitude of the POP. I take only the first 6 characters and store them with the POP
  2. When processing getpops, I calculate the Geohash for the current latitude/location, grab the first 6 characters and find any pops in the datastore that have the same stored Geohash.

My select statement is now a simple equals and runs far faster then my original implementation.


Overall Google App Engine is an interesting platform and baring some quirks it does appear to be a viable platform for building web applications on.

Bubbles! didn’t make it

Google Android Developer Challenge LogoJust received an email from the Android Developer Challenge team, seems that Bubbles! my Google Android application didn’t make it into round two:

_During the past few weeks, 100+ judges around the world reviewed over 1,700

applications. They were extremely impressed with the diversity and the

large number of high quality entries submitted. It is clear that the number

of great applications far exceeds the 50 top scoring applications that will

move on to the final round of the Android Developer Challenge._

_We regret to inform you that your entry was not among the top 50


Ah well it was worth a go. Apparently they are going to be putting up an Android Developer Challenge

Gallery shortly so we will get to see what I was up against.

Bubbles! – My Google Android Developer Challenge Entry

Google Android Developer Challenge LogoWell working into the wee hours of the morning I finally finished off my Google Android Developer Challenge entry.

Bubbles! allows you to create a pop (point of presence) that is ‘broadcasted’ from your phone. Other Bubbles! users in close proximity (about 50m) get to see your pop and you get see theirs. Of course as you move around so does your pop.

A pop is anonymous and consists of a message and a nick name that you choose for yourself.

Bubbles! Screenshots

I was going to implement a feature whereby you could tie a pop to a location. This would allow you to attach messages to a point in space for other users to see. Unfortunately I ran out of time but its next on my list to build.

Here are a few screenshots so you can see Bubbles! in action (click to see them full sized)

I’m also thinking of including the ability to see the history of pops for another user and perhaps even the ability to initiate a chat session with another Bubbles! user. Maybe even overlay the pops unto a MapView (which would hook into Google Maps) .

Of course if I get into the top 50 for the first round of the challenge I’ll have some money to invest into more development. We’ll have to see how I go but here’s hoping.