I wanted to give the SDK a good work-out so my application uses the GPS, the address book, and has a map.
The only way to judge an SDK is getting in there and writing an application that does something cool, so I'll take you through the development process for my first Android application: Where Are My Friends?
WamF shows how far away you are right now from all the people in your address book, plots you and them on a map, and draws lines between you and any friends nearby.
WamF is pretty simple but it makes use of some of the more interesting features of Android – Location Based Information (GPS etc), maps, the contacts manager, and the phone dialer. Total development time from hitting Download on the SDK page was about 14 hours (spread over two mornings and evenings). My Android development is in Windows with Eclipse using the plugin, so I will assume you're doing the same.
Before I get started here's a bit on my background. I've mentioned before that I'm a C# .NET desktop applications developer in my real life. It's been almost 10 years since I've done anything with Java and I've never done any mobile phone development. With Android I develop in Windows with Eclipse using the Android plugin.
Let's start by downloading Eclipse and unzipping it into a new folder. Then download the Android SDK and unzip that into another new folder. Open Eclipse and create a new workspace for Android development.
Install the Android Plugin by selecting Help > Software Updates > Find and Install..., and in the dialog box choose Search for new Features to install. Select New Remote Site and enter https://dl-ssl.google.com/android/eclipse/. into the dialog box. Hit OK and accept all the prompts until it's installed. Restart Eclipse and you're almost ready to rock.
Select Window > Preferences... and select Android, then put the folder where you unzipped the SDK into the SDK Location text box. Hit Apply then OK and you're done.
The tutorial and exercises are useful. Do them.
Let's make sure everything's installed right by creating the Hello Android demo. The Android team have a detailed description of how to do this so I won't repeat it here. It's worth checking out the known bugs if you encounter any problems.
The Android documentation is excellent; after you've finished the Hello Android project run through the exercises. They're easy to follow and give a good idea of how a 'real' application fits together.
Design a UI, leveraging one of the sample projects
Onto business. Step one should always be UI design. Figure out what it is you want to tell the user and what actions they'll need then develop an interface that will make this as intuitive as possible. To keep things simple I'm going to base my new project on the NotePad project used in the tutorial exercises.
I'll start by changing the resource strings to change the name of the app, and modifying the menu options .
Use the Location Based Services to figure out where we are and request updates when we move
Possibly the most enticing of the Android features are the Location Based Services that give your application geographical context through Location Providers (GPS etc). Android includes a mock provider called 'gps' that marches back and forth through San Fransisco. Alternatively you can create your own mock providers in XML.
You use the LocationManager to find your current position.
Iterate over the address book pulling out names, locations, and phone numbers
A less publicized feature of Android is the ability to share content between applications. We're going to use this feature to populate our List with our contacts' names and their current distance from our phone so we create an updateList method that we call after we've gotten our current location.
Use the ContentResolver to return a query that provides access to data shared using Content Providers. Queries are returned as cursors that provide access to the underlying data tables. The data we're interested in is accessed using the People content provider.
The Cursor is a managed way of controlling your position (Row) in the underlying table. We get access to the data by specifying the column that holds the information we're after. Rather than memorising the column index for each Content Provider we can use constants from the People class as a shortcut.
Now iterate over the table using the cursor storing the results in arrays. You'll note that we're pulling our contacts' location from the Notes field. In reality we'd want to figure this out based on their address using a geocoding lookup.
Then we assign our list of strings to the array using an ArrayAdapter.
Refresh our list when we move
Given the location sensitive nature of WamF it makes sense to update the display whenever we move. Do this by asking the LocationManager to trigger a new Intent when our location provider notices we've moved.
Intents in Android are like events in traditional event driven programming, so we're triggering a LOCATION_CHANGED event/intent every time we move by a minimum distance after a minimum time. The next step is to create an IntentReceiver (event handler), so create a new internal class that extends IntentReceiver and override the ReceiveIntent event to call our update method.
We then have our activity listen for a LOCATION_CHANGED intent by registering the event handler and specifying the intent it should be listening for (LOCATION_CHANGED). Do this in the onCreate method or create a new menu option to start/stop the automatic updates.
Keep your phone running light by registering / unregistering the receiver when the activity Pauses and Resumes – there's no point in listening for location changes if we can't see the list.
Set up a map activity and create an overlay to show where you are in relation to your friends
Half of the fun in having location sensitive information is drawing it on a map. Create a new activity class to display a map centered on our current location with markers at our friends locations. While we're at it we can draw a line from our position to each of our friends.
The map control itself is called a MapView, but we can only use a MapView in a MapActivity, so we'll change the inheritance of this activity to MapActivity.
To display the map we need to create a new MapView and set it as the content for our activity in the OnCreate method.
This will make the MapView fill the entire screen, so use views like LinearLayout if we want to create a more complicated UI layout.
We'll want to get access to the OverlayController and MapController, so create global variables to store them and assign the references within the OnCreate method. We'll also be using the Location information, so get a reference to that too. With the references assigned set your map zoom and starting location using the MapController. When you're finished OnCreate should look something like this.
updateView is where we do the work. Start by getting our current location and convert the Lat/Long to a map Point, then centre the map on our current location.
The only thing left to do on our map is draw markers and link them up with lines. To do this you need to create a new class that extends Overlay, and add this using the OverlayController.
The work in the Overlay class is done by overriding the draw method.
I start by drawing a 'marker' on my current location. There doesn't seem to be support for 'traditional' Google Maps markers but you can achieve the same thing by drawing on the map canvas; I chose to draw small circles as markers. First you need to use the PixelCalculator to convert your Lat/Long points to screen coordinates, then create a Paint object to define the colours and settings for your brush. Then paint your markers.
I add my friends locations the same way as before, iterating over my address book grabbing names and locations. I filter out anyone too far away (say 10km) and draw markers, names (drawText), and joining lines (drawLine) to those nearby.
Let's make a call
Now we know when we're close to our friends, what are we likely to want to do when we're close? Drop in! But we're polite so we'll call them first. Let's change our list item click function to call the friend we've clicked. We can do this by firing a DIAL_ACTION intent.
The phone dialer has registered an IntentReceiver filtered on DIAL_ACTION so it will react to this.
Android is an environment where the biggest limitation is your imagination
And that's it.
I've got a list of a dozen or so changes to make it a little more useful and a half dozen ideas for projects that might actually make it into the running for some of that prize money. My conclusion? Android is everything a development kit should be – an environment where the biggest limitation is what you can imagine.
>> More posts