Googles Android/ MapActivity

Zurück zu Googles Android

Neben der eigenständigen „Google Maps“-Anwendung, welche auf Android-Geräten zu finden ist, besteht die Möglichkeit, auch in der eigenen Anwendung Kartenmaterial von Google bereitzustellen. Zu diesem Zweck können Sie Activities als MapActivities implementieren, die genau diese Aufgabe erfüllen. Wie man diese Funktion umsetzt, wird nun im Folgenden gezeigt.

Vorbereitung

Um Karten in Ihrer Anwendung zu benutzen, müssen einige Voraussetzungen geschaffen werden.

SDK mit Google-API

Da es sich bei der Bereitstellung von Karten um einen Dienst von Google handelt, benötigen Sie nebst dem Android-SDK auch die API von Google. Zu diesem Zweck existiert zu jeder SDK-Version auch eine SDK-Version, die mit der Google-API ausgestattet ist. Um an das SDK mit Google-API zu kommen, müssen Sie diese, analog zur normalen „SDK-Version“, über den „Android SDK and AVD Manager“ auswählen und installieren.

Google-API-Key

Um den Kartendienst zu nutzen, müssen Sie sich für diesen zusätzlich noch registrieren. Eine genaue Anleitung, wie Sie Ihren Maps-API-Key erhalten, finden Sie hier. Für unsere Zwecke reicht es, wenn Sie die Registrierung mit Ihrem „SDK Debug“-Zertifikat durchführen. Sollten Sie später Anwendungen schreiben, die ihren Weg in den Android-Markt finden und Sie sich selbst ein privates Zertifikat erstellen, dann müssen Sie mit diesem einen neuen API-Key generieren (vorausgesetzt, Ihre Anwendung benötigt diesen).

Hinweis: Unter Java7 wird standardmäßig der SHA1-Schlüssel angezeigt. Um den MD5 Schlüssel zu sehen einfach -v an den keystore-Befehl anhängen

MapActivity selbst

Um nun einmal die MapActivity in Aktion zu erleben, brauchen wir ein neues Projekt. Also auf auf. Eclipse geöffnet und ein neues Androidprojekt gestartet. Geben Sie Ihrer Start-Activity den Namen HelloMapView ein!

Manifest

Zunächst müssen ein paar Änderungen am Manifest vorgenommen werden. So müssen wir als erstes die Maps Library unserem Projekt hinzufügen, da diese nicht zur Standard Library von Android gehört. Dazu fügen Sie bitte die Zeile

<uses-library android:name="com.google.android.maps" />

dem Manifest als untergeordneten Tag des <application>-Tags hinzu.

Des Weiteren benötigt die MapActivity Zugriff zum Internet, um neues Kartenmaterial herunterzuladen. Mit der Zeile

<uses-permission android:name="android.permission.INTERNET" /> 

als untergeordnetes Tag des <manifest>-Tags, erlauben wir der Anwendung die Kommunikation mit dem Internet.

Layout

Um später in der Activity die Karte einzublenden und mit dieser zu interagieren, müssen Sie im Layoutfile ein MapView-Tag anlegen, welches die Karte repräsentiert. Verändern Sie ihr main.xml, sodass es folgendem Code entspricht:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/mainlayout"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent" >

    <com.google.android.maps.MapView
        android:id="@+id/mapview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:clickable="true"
        android:apiKey="Your Maps API Key"
    />

</RelativeLayout>

• android:apiKey – Für dieses Attribut geben Sie Ihren API-Key an, welches Sie dazu berechtigt, den Kartendienst von Google zu nutzen und die Daten herunterzuladen.

Activity

Um die Anwendung abzurunden, müssen wir jetzt noch die MapActivity etwas bearbeiten.

1. Öffnen Sie die HelloGoogleMaps Activity und erweitern Sie diese mit MapActivity

public class HelloMapView extends MapActivity

Daraufhin müssen Sie mit Hilfe von Eclipse die benötigte Bibliothek importieren und die abstrakten Methoden der MapActivity einfügen. In diesem Fall wird nur die Methode boolean isRouteDisplayed() eingefügt. Diese wird genutzt, wenn Sie auf der Karte eine Route darstellen wollen. Da das bei uns nicht der Fall sein wird, geben wir false zurück.

2. In der onCreate()-Methode fügen Sie jetzt noch diese beiden Zeilen hinzu:

MapView mapView = (MapView) findViewById(R.id.mapview);
mapView.setBuiltInZoomControls(true);

Damit holen wir uns die Referenz auf unseren im Layoutfile definierten MapView. Mit setBuiltInZoomControls(true) fügen wir dem MapView einen ZoomIn- und ZoomOut-Button hinzu. Ohne diese beiden könnten wir die Karte auf nur einem Detaillevel hin- und herverschieben.

Im Grunde genommen haben wir bereits jetzt eine kleine (nicht unbedingt umfangreiche) Maps-Anwendung gebaut. Wir können die Karte verschieben und in diese hin- oder herauszoomen. Nun wollen wir aber noch die Möglichkeit schaffen, unsere Position durch einen Marker auf der Karte zu verdeutlichen (Nach dem Motto: Das X markiert die Stelle).

Dazu benötigen wir in unserem Projekt eine neue Klasse.

3. Erstellen Sie die Klasse HelloItemizedOverlay. Wenn Sie die Klasse über den Eclipse-Dialog erstellen, dann geben Sie als Superklasse com.google.android.maps.ItemizedOverlay an und machen Sie ein Häkchen bei Constructors from superclass. Anderfalls lassen Sie die neue Klasse von Hand von der Superklasse ItemizedOverlay erben. Achten Sie darauf, dass bei der Superklasse in den Pfeilen NICHT Item, sondern OverlayItem steht. Nachdem Sie auch noch die abstrakten Methoden der Superklasse eingefügt haben, sollte die Klasse wie folgt aussehen:

public class HelloItemizedOverlay extends ItemizedOverlay<OverlayItem> {

	public HelloItemizedOverlay(Drawable defaultMarker) {
		super(defaultMarker);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected OverlayItem createItem(int i) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return 0;
	}

}

Diese Klasse stellt eine zusätzliche Schicht dar, welche über die eigentliche Karte gelegt wird. Wir legen auf dieser Schicht unsere Marker ab, um von uns bestimmte Punkte besser hervorzuheben.

4. Als Nächstes braucht unsere Schicht eine Liste, in der sie die einzelnen Marker ablegen kann. Dafür erweitern wir die Klasse um ein ArrayList<OverlayItem>, in der wir die Marker speichern.

private ArrayList<OverlayItem> mOverlays = new ArrayList<OverlayItem>();

5. Später in der Anwendung wird die Position der Marker durch Geokoordinaten (Längen- und Breitengraden) angegeben. Damit sie nicht irgendwie auf dieser Position angezeigt werden, geben wir an, welche Stelle des Markers auf der Position liegt. In unserem Fall sagen wir, dass die Mitte der unteren Kante des Markers auf dem Geoposition liegt. Dazu erweitern Sie den Konstruktor um eine kleine statische Methode:

public HelloItemizedOverlay(Drawable defaultMarker) {
	super(boundCenterBottom(defaultMarker));
}

6. Nun müssen unsere Marker ja auch noch in das Overlay gebracht werden. Zu diesem Zwecks spendieren wir der Klasse eine weitere Methode:

public void addOverlay(OverlayItem overlay) {
    mOverlays.add(overlay);
    populate();
}

Mit addOverlay(OverlayItem overlay) fügen wir dem Overlay beziehungsweise der Liste einen weiteren Marker hinzu. Nachdem wir das gemacht haben, MÜSSEN wir die Methode populate() aufrufen, um bekannt zu geben, dass sich etwas an den zugrunde liegenden Daten beziehungsweise der Anzahl der Marker getan hat. In Folge des Aufrufs von populate() werden die Methoden size() und createItem(int i) unserer Klasse HelloItemizedOverlay aufgerufen. Dadurch werden die alten und auch der neue Marker auf dem Overlay neu dargestellt. Damit diese beiden Methoden richtig arbeiten, müssen sie noch an die Begebenheiten angepasst werden.

@Override
	protected OverlayItem createItem(int i) {
		return mOverlays.get(i);
	}

	@Override
	public int size() {
		return mOverlays.size();
	}

In beiden Fällen wird an unsere OverlayItem-Liste herangetreten, um die entsprechenden Informationen, die nötig sind, zu bekommen.

Damit sind wir mit der Arbeit an dieser Klasse für dieses Beispiel fertig. Als Letztes müssen wir in der Activity noch einige Veränderungen vornehmen, damit wir auch ein paar Marker auf die Karte bringen können.

• 
  1. Kartenmarker

7. Bevor wir zu den letzten Schritten im Programmcode kommen, brauchen wir noch die Grafik, die unseren Marker auf der Karte darstellt. Dazu kopieren Sie sich bitte die nebenstehende Abbildung 1 in den drawable-Ordner Ihres Projekts unter res/drawable-mdpi/ (res/drawable/, wenn Sie eine Android-Version unter 1.6 verwenden). ‎

8. Zunächst benötigt wir noch einige Klassenvariablen:

private List<Overlay> mapOverlays;		      // eine Liste mit allen Overlays des ''MapViews''
private Drawable drawable;				// das ''Drawable'' für unseren Marker
private HelloItemizedOverlay itemizedOverlay;		// unser Overlay

Welche dann in onCreate() instanziiert werden:

mapOverlays = mapView.getOverlays();	          // Damit wir später unser Overlay auf die Karte anwenden können, 
                                                     müssen wir uns vom ''MapView'' die Liste aller Overlays holen.
drawable = this.getResources().getDrawable(R.drawable.arrow_down); // Aus den Ressourcen holen wir uns unser Bild des Markers …
itemizedoverlay = new HelloItemizedOverlay(drawable);		   // … und setzten es als Defaultmarker in unseren Overlay.

Jetzt brauchen wir noch die Position, an der unser Marker auf der Karte angezeigt werden soll.

GeoPoint point = new GeoPoint(52457270,13526380);
OverlayItem overlayitem = new OverlayItem(point, "", "");

Dem GeoPoint werden die Koordinaten als Längen- und Breitengraden angegeben. Zu beachten ist, dass die normalen Grade mit 10^6 mal genommen werden müssen. Bsp: Aus 52,45° werden 52450000. Diese Position wird einem OverlayItem als Parameter übergeben, damit dieses an der gewünschten Position angezeigt wird.

Als letzten Schritt fügen wir das gerade erstellte OverlayItem unserem Overlay und dieses Overlay der Liste der Overlays des MapView hinzu.

itemizedOverlay.addOverlay(overlayitem);
mapOverlays.add(itemizedOverlay);

Wenn wir nichts vergessen haben, können Sie die Anwendung einmal laufen lassen. Sie können über die gesamte Weltkarte navigieren, hinein- und herauszoomen und Sie werden einen Marker finden, den Sie aber erst einmal finden müssen.