2Lines Software » Android

Singletons and Services and Shutdowns Oh My

john — Wed, 04 Aug 2010 03:38:58 +0000

Passing data back and forth between activities on the Android platform is one of the more challenging aspects of understanding Android. Understanding how this data is managed by the OS is the difference between getting flooded with Error Reports and bad reviews and getting glowing praise and eternal gratitude. Well maybe not to that extent, but having a good background in passing data can make your code much easier to manage and cleaner to read (and for that you have my gratitude) So in passing the data there are essentially two types Persistent and strangely enough, Non-Persistent data types. The Persistent types are best handled by preferences, files, databases or content providers and they are pretty detailed in their operation. If you need to keep data over the length of more that one session consider using Persistent data stores. On the other hand, there are often times where transient data needs to be stored for one session and passed between activities. To handle that there are a couple of ways to handle it. This page details some of the methods, and it is repeated here for convenience;

How do I pass data between Activities/Services within a single application?

It depends on the type of data that you want to share:

Primitive Data Types

To share primitive data between Activities/Services in an application, use Intent.putExtras(). For passing primitive data that needs to persist use the Preferences storage mechanism.

Non-Persistent Objects

For sharing complex non-persistent user-defined objects for short duration, the following approaches are recommended:

The android.app.Application class

The android.app.Application is a base class for those who need to maintain global application state. It can be accessed via getApplication() from any Activity or Service. It has a couple of life-cycle methods and will be instantiated by Android automatically if your register it in AndroidManifest.xml.

A public static field/method

An alternate way to make data accessible across Activities/Services is to use public static fields and/or methods. You can access these static fields from any other class in your application. To share an object, the activity which creates your object sets a static field to point to this object and any other activity that wants to use this object just accesses this static field.

A HashMap of WeakReferences to Objects

You can also use a HashMap of WeakReferences to Objects with Long keys. When an activity wants to pass an object to another activity, it simply puts the object in the map and sends the key (which is a unique Long based on a counter or time stamp) to the recipient activity via intent extras. The recipient activity retrieves the object using this key.

A Singleton class

There are advantages to using a static Singleton, such as you can refer to them without casting getApplication() to an application-specific class, or going to the trouble of hanging an interface on all your Application subclasses so that your various modules can refer to that interface instead. But, the life cycle of a static is not well under your control; so to abide by the life-cycle model, the application class should initiate and tear down these static objects in the onCreate() and onTerminate() methods of the Application Class [my emphasis]

Being as I come from a java EE background the first decision was to use the singleton class and allow the instance to be available across the VM. The singleton design pattern is fairly well-known and is a good easy way to manage control across many activities. In some previous projects I have used them to manage HTTP connections, image caching and global application configuration to much success. However, this is the important part to consider when using singletons which is very important; Android OS can and will terminate your singleton and not even tell you about it. I highlighted that in bold because if your design depends on singleton patterns you naturally assume they are going to stay persistent through the VM. These are frustrating errors and difficult to track down and even more frustrating for your users. For instance consider this piece of code: In your main activity;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

SuperSingletonManager.create(this);

}

And your singleton;

private static SuperSingletonManager instance;

private SuperSingletonManager(Context context)

{

// do stuff once

}

protected static SuperSingletonManager create(Context context) {

instance = new SuperSingletonManager(context);

}

protected static SuperSingletonManager getInstance() {

if (instance == null)

throw new NastyException("Oh God Why?");

return instance;

}

Seemingly you should be able to call SuperSingletonManager.getInstance() at any time and get access to the static instance. However, this isn't the case. If the launching activity is removed by the OS (it happens, a lot) while you are on another activity, that static instance will be gone. So when you make that SuperSingletonManager getInstance() call you are only going to get a nasty exception. This also means that if any of your functions in SuperSingletonManager make use of the Context those will throw errors. Ack. But I really, really like singletons. So do I. And far be it from me to tell you how to architect your code. The only stipulation is that the singleton should abide by the lifecycle model. We can do this by launching the singletons from a service and binding that service to the launching activity. To the Android purists, and common-sensists out there you might just say "Why not just use a service instead of a singleton?". Sure, makes sense but this post is about singletons and how to get them working and not common-sense. So here is the class that will do all that;

public class SingletonService extends Service {

private final ISingletonService.Stub mBinder = new ISingletonService.Stub() {

public void startSingletons() throws RemoteException {

initializeSingletons();

}

public void stopSingletons() throws RemoteException {

shutdownSingletons();

}

};

public IBinder onBind(Intent intent) {

return mBinder;

}

protected void initializeSingletons() {

SuperSingletonManager.initialize(getApplicationContext());

}

private void shutdownSingletons() {

SuperSingletonManager.shutdown();

}

}

When you start your main activity bind the service using bindService() , and make a call to the startSingletons() method. This will launch your singletons under the lifecycle of the service. This will ensure they are active for the life of your application session. Also, make sure to unbindService when you are finished. Nobody likes developers that don't clean up after themselves. Good luck and if you actually use this method let me know! John

Posted via email from John Carpenter

Getting Android SDK to work with Fedora 10

john — Sun, 01 Feb 2009 01:05:40 +0000

Just thought I pass this little bit of information on. Fedora 10 (and Ubuntu also) is a little screwy when it comes to connecting the ADP1 device to Eclipse for testing.

Any USB device automatically gets connected as read-only which means the adb server and Eclipse won´t see the device when you plug it in.

This post gives a little information on how to fix it.

The idea is to create a rules file that listens for the Android device and sets the permissions differently. The rules are all located under /etc/udev/rules.d. So in detail,

Create a new rule for Android devices

vi /etc/udev/rules.d/99-android.rules

Add the following code

SUBSYSTEM=="usb",SYSFS{idVendor}=="0bb4",SYMLINK+="android_adb",MODE="0666"

And run

udevcontrol reload_rules

Plug it in and it should work.

WikiWhere the Video

john — Thu, 22 Jan 2009 06:50:22 +0000

Here is the fully functioning WikiWhere Application.

Feel free to add / remove / update or delete the app as you see fit!

Programming with Android Part 4 – Finishing WikiWhere

john — Thu, 22 Jan 2009 06:22:25 +0000

Continuing from Part 3 we are going to spend the 30 minutes or so to finish the WikiWhere application. So far we have a mapping and location application on the device. The final step is integrating the Wiki sites and displaying them on the map.

1:45 Foosball, Reddit, Digg and Google Reader Break

1:55 Getting the XML feed for the Wiki sites

Now that you've had a long break we can get to the more complicated sections of the code. The Wiki information is collected and provided as a web service by Geonames.org. We will be using the wikipediaBoundingBox XML API to get the information from the service. By making a call to http://ws.geonames.org/wikipediaBoundingBox?north=51.1&south=50.1&east=-113&west=-115 you can get the XML feed of the Wiki Entries in the bounding box in the following format:

>
>
>en>
>Max Bell Centre>
>The Max Bell Centre (often referred to as the Max Bell
Arena) is an ice hockey arena in Calgary, Alberta, Canada in the
community of Radisson Heights. It seats 2,121 for hockey with a
standing room capacity of over 3,000. It is named after George
Maxwell Bell, a philanthropist who helped fund the arena's
construction (...)>
>landmark>
>CA>
>0>
>0>
>51.0422>
>-114.0036>
>http://en.wikipedia.org/wiki/Max_Bell_Centre
>
/>
>
...
>

So to get our wiki items displayed on the map we need to:

1. Call the Geonames XML API

2. Parse the XML

3. Display the icons on a MapOverlay

4. Implement the "Search For Wiki Entries" Button

Step 1. Call the Geonames API

Android comes built in with the HttpClient code from Apache Foundation, which gives it a very flexible tool in accessing web services. For WikiWhere we will create two classes to handle the API calls. GeonameManager will be responsible for making the HTTP request and parsing the XML, and much like the LocationListener, GeonameListener will push the messages back to the WikiWhere Class. GeonameManager:

public class GeonameManager {

private GeonameListener listener;
private static final String WS_URL = "http://ws5.geonames.org/wikipediaBoundingBox?";
public GeonameManager(GeonameListener _listener){
listener = _listener;
}
public void readFromUrl(double minLat, double maxLat, double minLon, double maxLon) {
StringBuffer sb = new StringBuffer();
sb.append(WS_URL);
sb.append("north=");
sb.append(maxLat);
sb.append("&south=");
sb.append(minLat);
sb.append("&west=");
sb.append(minLon);
sb.append("&east=");
sb.append(maxLon);
String httpUrl = sb.toString();
URL url;
URLConnection connection = null;
try{
HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, 5000);
HttpClient httpclient = new DefaultHttpClient(params);
HttpGet httpGet = new HttpGet(httpUrl);
HttpResponse response = httpclient.execute(httpGet);
WikiItems wi = parseXML(response.getEntity().getContent());
listener.newWikiItems(wi);
}catch(Exception e){
listener.newError("Network error:"+e.getMessage()+". Please try again later");
}
}
private WikiItems parseXML(InputStream in){
XStream xstream = new XStream(new DomDriver());
xstream.alias("geonames", WikiItems.class);
xstream.alias("entry",WikiEntry.class);
xstream.addImplicitCollection(WikiItems.class, "entries");
WikiItems wi = (WikiItems) xstream.fromXML(in);
return wi;
}
}

and GeonameListener..

public interface GeonameListener {

public void newWikiItems(WikiItems wi);
public void newError(String message);
}

The method to call the API (readFromUrl) makes a simple HTTP connection in the running thread. Once the connection is made, the InputStream is pushed to the parseXml() method.

Step 2. Parse the XML

This is where I cheat to save time. I have imported the open source XStream library to parse the XML. XStream is a very powerful tool used to serialize XML to Java Objects. By taking the source code and importing it into our project we can leverage the XStream tools in the Android environment. I have modified the code to work with the Android parsers and you can download it from here:

XStream for Android Source

To use the XStream parser we first have to create two classes, WikiItems and WikiEntry, to hold the XML information as a Java Object.

public class WikiEntry {

private String lang;
private String title;
private String summary;
private String feature;
private String countryCode;
private int population;
private double elevation;
private double lat;
private double lng;
private String wikipediaUrl;
private String thumbnailImg;
public String getLang() {
return lang;
}
public void setLang(String lang) {
this.lang = lang;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSummary() {
return summary;
}
public void setSummary(String summary) {
this.summary = summary;
}
public String getFeature() {
return feature;
}
public void setFeature(String feature) {
this.feature = feature;
}
public String getCountryCode() {
return countryCode;
}
public void setCountryCode(String countryCode) {
this.countryCode = countryCode;
}
public int getPopulation() {
return population;
}
public void setPopulation(int population) {
this.population = population;
}
public double getElevation() {
return elevation;
}
public void setElevation(double elevation) {
this.elevation = elevation;
}
public double getLat() {
return lat;
}
public void setLat(double lat) {
this.lat = lat;
}
public double getLng() {
return lng;
}
public void setLng(double lng) {
this.lng = lng;
}
public String getWikipediaUrl() {
return wikipediaUrl;
}
public void setWikipediaUrl(String wikipediaUrl) {
this.wikipediaUrl = wikipediaUrl;
}
public String getThumbnailImg() {
return thumbnailImg;
}
public void setThumbnailImg(String thumbnailImg) {
this.thumbnailImg = thumbnailImg;
}
}

..and,

public class WikiItems {

private ArrayList entries;
public ArrayList getContent() {
return entries;
}
public void add(WikiEntry item){
entries.add(item);
}
}

You can see they are both fairly simple java classes using the tag names from the XML as field names.

Next you tell the XStream parser which classes map to which XML tags.

XStream xstream = new XStream(new DomDriver());

xstream.alias("geonames", WikiItems.class);
xstream.alias("entry",WikiEntry.class);
xstream.addImplicitCollection(WikiItems.class, "entries");

and call the fromXML method.
WikiItems wi = (WikiItems) xstream.fromXML(in);

That's it. If you've ever had the hairpulling experience of parsing XML files on a mobile device you will be pleasantly surprised at how easy XStream is to use.

Step 3. Display the Icons on the MapOverlay

Going back to our WikiWhere activity we want to add the GeonameListener to receive the updates from the HTTP web service of new WikiItems loaded.

public class WikiWhere extends MapActivity implements LocationListener, GeonameListener {

and implement the onNewWikiItems method;

public void newWikiItems(WikiItems wi) {
List overlays = mv.getOverlays();
Drawable marker = getResources().getDrawable(R.drawable.mapicon);
marker.setBounds(0, 0, marker.getIntrinsicWidth(), marker.getIntrinsicHeight());
wikiOverlay = new WikiOverlay(marker,wi,this);
overlays.add(wikiOverlay);
handler.sendEmptyMessage(0);
}

Don't worry about the handler.sendEmptyMessage(0) call just yet. We'll get to that one soon.

The next part we will create a custom map overlay to handle placing the icons on the map when new wiki's are sent from the GeonameListener. Androids ItemizedOverlay provides a convenient way to handle multiple icons on a map. We implement this by extending it in a creating a class call WikiOverlay.

public class WikiOverlay extends ItemizedOverlay {
@Override
protected boolean onTap(int index) {
listener.onTap(wi.getContent().get(index));
return super.onTap(index);
}
private WikiItems wi;
private ArrayList items;
private ActionListener listener;
public WikiOverlay(Drawable defaultMarker, WikiItems _wi, ActionListener _listener) {
super(defaultMarker);
items = new ArrayList();
listener = _listener;
wi = _wi;
for(WikiEntry we:wi.getContent()){
GeoPoint g = new GeoPoint((int)(we.getLat()*1E6),(int)(we.getLng()*1E6));
OverlayItem oi = new OverlayItem(g,we.getTitle(),we.getSummary());
items.add(oi);
}
populate();
}
@Override
protected OverlayItem createItem(int i) {
return items.get(i);
}
@Override
public int size() {
return items.size();
}
}

The WikiOverlay converts the WikiEntry items into the standard OverlayItem that MapView is expecting. Once the populate() method is called the MapView will render the map icons onto the map. Pay attention to the onTap method and ActionListener we will come back to them shortly.

Special update ! Resources !

Android has a unique way of managing the resources in an application by creating the R.java file. This file provides a link between the physical resources on the disk and a way to access them from inside the code. This means no more complicated pulling from resource files to access images or properties files. Localization is handled automatically by populating different directory names(i.e. res/values-fr/string.xml for French).

Try copying this png (Wiki Map Icon) into the directory res/drawable. Now refresh/open the R.java file. You should see a line that looks something like this:

public static final int mapicon=0x7f020001;

That link is automatically generated and will give you access to the resource from any class and you can change it at anytime. Here is the relevant code snippet that access the mapicon png image and loads it into a Marker classfor display on the map.

Drawable marker = getResources().getDrawable(R.drawable.mapicon);

This method of handling resources is used for strings, raw binary files (mp3s or mp4s), images and any other static file that is referenced by the code. It is a great way to handle configuration changes and localization in different devices. Again it shows a solid separation of graphic design from the programmers!.

Step 4. Implement the "Search For Wiki Entries" Button

The last step is to link the users request with the HTTP API call from the GeonameManager. We've implemented a button at the very beginning called "Search For Wiki Entries" that can be seen on the main page. We will use this button to send the HTTP request out.

In order to prevent the blocking operation on the main activity and effectively freeze the UI (and draw your users into a mad frenzy button mashing panic) we will create a worker thread running in the background to handle this. The worker thread will also turn on and off the waiting animation for the user.

Here is an important note: you cannot update a UI from any thread outside the main class where it was instantiated. That is; our background communications thread cannot make changes to the UI. In order to get around this Android includes a Handler class that queues requests in the main thread. Here is the code implemented at the start of WikiWhere class.

private Handler handler = new Handler(){

public void handleMessage(Message msg){
dialog.dismiss();
if(msg.getData().containsKey("error")){
showError(msg.getData().getString("error"));
}
mv.invalidate();
}
};

To update our UI from the communications worker thread we post a Message to the handler. Since the handler runs in the main thread it can update the UI

The worker thread is implemented as an inner class in the WikiWhere main class. Here is the code for the worker thread:

private class LoadingThread extends Thread{

private GeonameManager gm;
private double minLat;
private double maxLat;
private double minLng;
private double maxLng;
public LoadingThread(double _minLat,double _maxLat,double _minLng,double _maxLng,GeonameManager _gm){
gm = _gm;
minLat = _minLat;
maxLat = _maxLat;
minLng = _minLng;
maxLng = _maxLng;
}
public void run() {
gm.readFromUrl(minLat, maxLat, minLng, maxLng);
}
}

Finally we can call the thread by implenting the onClickListener for the button. So in the initMap() method we added the following code

button = (Button) findViewById(R.id.search);

button.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
loadWiki();
}
});

and also added a new method to instantiate the loading;

private void loadWiki(){

dialog = new ProgressDialog(this);
dialog.setTitle("Wiki, Where");
dialog.setMessage("Getting Wiki Data...");
dialog.setIndeterminate(true);
dialog.setCancelable(true);
dialog.show();
GeoPoint center = mv.getMapCenter();
double minLat = (double)(center.getLatitudeE6()-(mv.getLatitudeSpan()/2)) / 1E6;
double maxLat = (double)(center.getLatitudeE6()+(mv.getLatitudeSpan()/2)) / 1E6;
double minLng = (double)(center.getLongitudeE6()- (mv.getLongitudeSpan()/2) ) / 1E6;
double maxLng = (double)(center.getLongitudeE6()+ (mv.getLongitudeSpan()/2)) / 1E6;
LoadingThread process = new LoadingThread(minLat,maxLat,minLng,maxLng,gm);
process.start();
}

Run the app again and click on the button. It should launch a dialog and load the wiki items near that map location.If everything goes right you should see the blue wiki icon on the map like this;

Good app but let's add the last part to pull up information on that wiki locationin a separate web page.

2:15 Final Steps

The last step will involve listening for the user to click on a wiki item and display that wiki page to the user.

Remember back when we skipped over the ActionListener? Well, let's go back and add that interface into the WikiWhere class and extend the onTap() function;

public class WikiWhere extends MapActivity implements LocationListener, GeonameListener, ActionListener {

Plus,
<pre lang="java5"> public void onTap(WikiEntry we) {
mc.animateTo(new GeoPoint((int) (we.getLat() * 1E6),
(int) (we.getLng() * 1E6)));
final Dialog dialog = new Dialog(this);
dialog.setContentView(R.layout.web);
dialog.setTitle(we.getTitle());
dialog.setCancelable(true);
WebView web = (WebView) dialog.findViewById(R.id.web);
web.loadUrl(we.getWikipediaUrl());
web.setInitialScale(50);
dialog.show();
}

The onTap() method listens from the WikiOverlay and waits for a user to tap one of the OverlayItems. We overload this method with ActionListener and pass back the WikiEntry reference that was selected.
This new method does a couple of things. First, it pans the map to center on the wiki location. Second, it launches a new WebView within a dialog. WebViews are fully functioning WebKit browser pages and essentially the same browser that is on the device. Simply by calling web.loadUrl() you can call up any web page and display it to the user.Â This by itself is a fantastic tool for development.
However, we will have to first create the layout resource XML file. Create a file called web.xml in the res/layoutÂ directory and add the following to it;

xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
android:id="@+id/web" android:layout_width="wrap_content"
android:layout_height="fill_parent" android:padding="10px" />
>

2:30pm We're Finished!
Congratulations you've just created your first app from scratch in less time than it takes to install a windows update.
Download the full source code here:

WikiWhere Source Code

Bonus Points!
To truly see how powerful the application environment and tools are you will need a device.Â Sign up to http://market.android.com to become a registered developer. This gives you access to publish your applications and buy a development phone directly from Google. The phone is only $399USD but that doesn't include shipping and duty, which in some cases (Canada) can be over $250! Wait, what happend to NAFTA?
Once you get your device simply install the USB drivers and plug in your phone. The drivers will immediately recognize it. Now when you click Run in Eclipse you can execute the program on the phone including all the debugging and monitoring tools. Completely seemless emulator and device testing environment. It's like having your cake (not a lie) and eating it too!

Programming with Android Part 3 – Building WikiWhere

john — Wed, 21 Jan 2009 02:55:00 +0000

We will continue from where we left off in the last instalment and extend our basic application into a more useful application. If you are keeping track, we're an hour and fifteen minutes into our development and we have our application environment setup and ready to program in Android.

Over the next hour we will create an application that will show the wiki entries near our location, display that information on a map and embed the wiki page into the application. This application highlights three key features of the Android platform;

Focus on LBS that makes locative media easier to produce.
Deep web integration from consuming web services to embedding web page.
Â Simple map integration via Google Maps.

What is WikiWhere

WikiWhere is a buzzword-compliant mobile application that gives you access to local wiki knowledge where ever you are. Using your Android phone, WikiWhere searches wiki for entries near your location and passes that information to you. Discover your neighbourhood or visit others.Â

1:20 Back from Break. You aren't paid to sit there you know.

We are now going to get started with the WikiWhere application. Let's go through the first step and create an application shell using the Eclipse project builder. Just as in the previous part, select File >> New Project >> Android Project to launch a new project. Add the details for WikiWhere. I've attached a screenshot of the details below.

Step 1. Create the MapView

The main user interface will be a MapView so we want to change the interface of our WikiWhere class from Activity to MapActivity and implement the onRouteDisplayed method.

package demo.WikiWhere;
import com.google.android.maps.MapActivity;
import android.app.Activity;
import android.os.Bundle;
public class WikiWhere extends MapActivity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
protected boolean isRouteDisplayed() {
return false;
}
}

Next we have to implement the map in the view. Android separates the device layout / views from the source code to simplify development. A graphic designer can modify the XML layout without impacting the underlying source code. I'm a strong believer in letting programmers do the programming and not the UI or graphic design. Windows 3.1 was designed by programmers. Case closed.

The layouts are located in the res/layout folder in the project. We will edit the main.xml file and replace it with the following code:

xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
<Button android:id="@+id/search" android:layout_width="fill_parent"
android:layout_height="wrap_content" android:text="Search For Wiki Entries"/>
<com.google.android.maps.MapView
android:id="@+id/map" android:layout_width="fill_parent"
android:layout_height="wrap_content" android:layout_below="@+id/search"
android:apiKey="YOUR-GOOGLE-MAPS-API-KEY"
android:enabled="true" android:clickable="true"/>
<LinearLayout android:id="@+id/zoom_holder"
android:layout_width="fill_parent" android:layout_height="fill_parent"
android:gravity="bottom|center_horizontal" />
</RelativeLayout>

This layout file adds three components. At the top will be a button to search for wiki entries. The main view is a Google Maps view. And finally, the bottom component is a holder for the zoom in/out control on the map. You will have to apply for your own Google Maps key and you can do that from this site

Step 2. Permissions

The next step is to tell Android that we need access to the maps library and permission to access the internet from the device. All the configurations is located in the AndroidManifest.xml file. This file controls all the permissions and OS access for the application. It would be worth your while to become very familiar with that file. The Android/Eclipse toolkit provides a graphical interface to simplify the editing of the file. Personally, I prefer to use the raw xml (click on the far right tab when in the graphical interface) but really its up to you.

The first step is to add the library to the application. Add the

>
android:name="com.google.android.maps">>
/>

Next, we will add the permissions to the file:

..>
android:name="android.permission.INTERNET">>

This is all the changes that need to occur to get a MapView running on the device. If you setup a Run Configuration identical to Part 2 and run the application in the emulator you should see this;

That's it for adding a draggable map into your application. Click and drag the map around.

Step 3. Adding Extra Components

As a final step we will add a zoom button and center the map on a closer area. Add this code to your WikiWhere.java file;

private double START_LAT = 51.066832;
private double START_LNG =-114.086108;
private int START_ZOOM = 15;
private MapController mc;
private MapView mv;
private View zoomView;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
initMap();
}
private void initMap(){
mv = (MapView)findViewById(R.id.map);
mc = mv.getController();
// Initialise the map
mc.setZoom(START_ZOOM);
mc.setCenter(new GeoPoint((int)(START_LAT*1E6),(int)(START_LNG*1E6)));
mv.setSatellite(true);
mv.setStreetView(false);
LinearLayout zoom = (LinearLayout)findViewById(R.id.zoom_holder);
zoomView = mv.getZoomControls();
zoomView.setLayoutParams(
new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT,
ViewGroup.LayoutParams.WRAP_CONTENT
)
);
zoom.addView(zoomView);
mv.displayZoomControls(true);
}

This adds a zoom panel at the bottom, centers the map on a location (Kits Bar in Calgary, AB. home to MobileMonday Calgary every month) and adds a satellite overview to the map. Go ahead run the app again. Pretty cool, huh?

1:40 Accessing the On-Device Location

This next section deals with getting the devices current location from GPS. Android provides a simple interface through the LocationManager to get the location. An important differentiator of the LocationManager is that it listens to the location stream and therefore allows many applications to access the GPS on the device. Many other GPS implementations on mobile devices don't allow multiple applications to access the location. This is a major drawback to running background applications since the OS would dictate which applications receive the location and which ones are stopped. This architecture also means that the time for a location fix is drastically reduced in the device. I will be writing an article outlining the importance of this architecture in an upcoming article on the Android GPS accuracy.

Either way, back to WikiWhere. Androids permission scheme requires that the permissions for GPS and in fact all location types be entered into the AndroidManifest.xml first.

Add the following lines under the other

android:name="android.permission.ACCESS_COARSE_LOCATION">>
android:name="android.permission.ACCESS_FINE_LOCATION">>
android:name="android.permission.ACCESS_MOCK_LOCATION">>

As I mentionned above the GPS is pushed through a LocationListener. We will be implementing that interface in the WikiWhere class and extending the LocationListener methods in the code.

public class WikiWhere extends MapActivity implements LocationListener {

Initializing the LocationManager is done by calling requestLocationUpdates

private LocationManager lm;
private MyLocationOverlay lo;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
initMap();
initLocation();
}
private void initLocation(){
lm= (LocationManager) this.getSystemService(LOCATION_SERVICE);
lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 5000, 500, this);
}

The requestLocationUpdates allows you to tailor your listener so you only get updates when a user has moved a certain distance and/or a certain time has passed. In our example above we are getting locations every 5 seconds (5000 ms) or when the user moves more than 500m. Location objects will be pushed to the onLocationChangedMethod whenever updates are available.

For the next part we will create an Overlay to display the users position. Overlays are Androids way of handle icons on a map. There is a default overlay called MyLocationOverlay that is specifically designed to handle the users location updates from GPS. If you were so inclined feel free to write your own map Overlay for the users locations. (We will be doing that later for the Wiki Points).

public void onLocationChanged(Location location) {
List overlays = mv.getOverlays();
lo = new MyLocationOverlay(this,mv);
overlays.add(lo);
lo.enableMyLocation();
}

That code will update the location and display it on the map. Save and run the application on the emulator.

The first thing you will notice is that there is no flashing blue icon on the map. That is because no location has been sent to the emulator. The Android SDK provides a toolkit to help you out here. Select Window>>Open Perspective>>DDMS (You may have to click other and browse for it, if it isn't there). This perspective gives you a large collection of tools to help optimize, debug and monitor applications on the emulator (and devices!). Under the Emulator Control tab scroll down until you see the Location Controls.

Â ThisÂ control allows you to push one location or a series of locations in GPX or KML format. A fantastic tool for testing applications. Enter the latitude and longitude into the box and click send. This will simulate a GPS location coming into the device and you should immediately see the flashing blue icon in your emulator.

Locations are automatically updated everytime you move. Try playing around with the DDMS Location Control and see how it moves your position around dynamically.

Â That is it for the first part of WikiWhere. In the next part we will learn how to call web services, simple parsing of XML and of course the WebView. See you then!

Â Final Part