Erstellen Sie ein benutzerdefiniertes Uhr-Widget: Implementieren der Benutzerkonfiguration

German (Deutsch) translation by Federicco Ancie (you can also view the original English article)

Das Entwickeln von Widgets für die Android-Plattform beinhaltet etwas andere Aufgaben als die Standard-App-Entwicklung. In dieser Reihe von Tutorials werden wir den Prozess der Entwicklung eines anpassbaren analogen Uhr-Widgets durcharbeiten. Die Uhr basiert auf der Android AnalogClock-Klasse und wird mit Ihren eigenen Grafiken angepasst.

Bisher haben wir in dieser Serie das Widget in XML und Java entworfen und implementiert und verfügen über ein funktionierendes Uhr-Widget, das der Benutzer seinem Homescreen hinzufügen kann. In diesem letzten Teil der Serie werden wir die grundlegende Benutzerkonfiguration implementieren. In Teil 2 haben wir mehrere Uhrendesigns erstellt, sodass der Benutzer nun zwischen diesen wählen kann.

Dies ist Teil 4 von 4 in einer Reihe zum Erstellen eines anpassbaren Android-Analoguhr-Widgets in vier Tutorials:

Das Einbinden der Benutzerkonfiguration in unsere Widget-App umfasst eine neue Java-Aktivitätsklasse, die dem Benutzer die Auswahlmöglichkeiten bietet. Wenn der Benutzer ein Design auswählt, aktualisieren wir das Erscheinungsbild des Widgets und speichern die Benutzerauswahl in den freigegebenen Einstellungen der Anwendung. Wir werden auch die Widget-Klasse erweitern, um Benutzerklicks auf das Widget zu verarbeiten und aus den freigegebenen Einstellungen nach Wahl des Benutzers zu lesen. Neben der Arbeit mit diesen beiden Java-Dateien erstellen wir eine neue Wertedatei und eine XML-Layoutdatei für die ausgewählte Aktivität sowie einige Bilder, die darin angezeigt werden sollen.

Schritt 1: Widget Klicks verarbeiten

Fügen wir zunächst der Widget-Klasse Code hinzu, um Benutzerklicks zu erkennen. Fügen Sie in der Klasse "ClockWidget" in der Anweisung "if" in der Methode "onReceive" nach der Zeile, in der wir das Remote Views-Objekt abgerufen haben, den folgenden Code hinzu, um eine Absicht für die Auswahlaktivität zu erstellen, die wir verwenden möchten:

1	Intent choiceIntent = new Intent(context, ClockChoice.class);

Machen Sie sich keine Sorgen über die Eclipse-Fehler, sie verschwinden, wenn wir im nächsten Schritt die neue Aktivitätsklasse erstellen. Erstellen Sie nach dieser Zeile eine ausstehende Absicht wie folgt:

1	PendingIntent clickPendIntent = PendingIntent.getActivity
2	(context, 0, choiceIntent, PendingIntent.FLAG_UPDATE_CURRENT);

Wie Sie sehen, ist das Starten von Aktivitäten mit Widget-Klicks etwas anders. Beachten Sie, dass wir das Context-Objekt und einen Verweis auf die neue Absicht übergeben. Fügen Sie nun den folgenden Code hinzu, der angibt, dass die ausstehende Absicht gestartet werden soll, wenn auf das Widget geklickt wird:

1	views.setOnClickPendingIntent(R.id.custom_clock_widget, clickPendIntent);

Wir geben das Widget an, indem wir uns auf die ID des übergeordneten Layouts in der XML-Datei "clock_widget_layout" beziehen. Wir müssen die Remote-Ansichten verwenden, um auf die Elemente der Benutzeroberfläche zu verweisen, da wir uns in einer Widget-Klasse und nicht in einer Aktivitätsklasse befinden. Wir werden dieser Klasse später mehr Code hinzufügen.

Schritt 2: Erstellen Sie eine Auswahlaktivität

Nun zu der Aktivität, in der Benutzer ein Design auswählen können. Erstellen Sie eine neue Klasse in Ihrem Projekt, indem Sie mit der rechten Maustaste auf den Quellpaketordner klicken oder ihn auswählen und "Datei" auswählen. Wählen Sie dann "Neu", "Klasse" und geben Sie "ClockChoice" als Klassennamen ein. Eclipse öffnet die neue Klasse, wenn Sie auf Fertig stellen klicken. Denken Sie daran, dass wir diese Aktivität in die Projektmanifestdatei in Teil 1 aufgenommen haben.

Machen Sie Ihre neue Klasse zu einer Aktivität, die Benutzerklicks verarbeitet, indem Sie die Eröffnungszeile wie folgt erweitern:

1	public class ClockChoice extends Activity implements OnClickListener {

Ignorieren Sie einfach alle Fehlermeldungen. Sie werden angezeigt, bis wir die "onClick" -Methode bereitstellen. Sie benötigen die folgenden Importanweisungen:

1	import android.app.Activity;
2	import android.view.View.OnClickListener;

Stellen Sie die Activity "onCreate" -Methode in der Klasse wie folgt bereit:

public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.clock_choice);

}

Wir werden die Layoutdatei im nächsten Schritt erstellen. Sie benötigen einen weiteren Import:

1	import android.os.Bundle;

Wir werden dieser Klasse später mehr Code hinzufügen.

Schritt 3: Auswahl des Aktivitätsdesigns

Lassen Sie uns das Layout erstellen, das wir oben in der Aktivitätsklasse angegeben haben. Erstellen Sie eine neue Layoutdatei, indem Sie mit der rechten Maustaste klicken oder den Ordner "res/layout" auswählen und "Datei" auswählen, dann auf "Neu", "Datei" klicken und "clock_choice.xml" eingeben, um der Referenz im obigen Code zu entsprechen.

Wenn Eclipse die Datei öffnet, wählen Sie die Registerkarte "clock_choice.xml", um den Code zu bearbeiten. Geben Sie die folgende Layoutskizze in Ihre Datei ein:

<ScrollView xmlns:android="https://schemas.android.com/apk/res/android"
	android:layout_height="wrap_content" 
	android:layout_width="fill_parent">
	<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
		android:orientation="vertical" 
		android:layout_width="wrap_content" 
		android:layout_height="wrap_content"
		android:padding="10dp">
	
</LinearLayout>
</ScrollView>

Das Design enthält ein lineares Layout in einer Bildlaufansicht. Fügen Sie im linearen Layout zunächst einen informativen Text wie folgt hinzu:

<TextView 
	android:layout_width="wrap_content" 
	android:layout_height="wrap_content" 
	android:text="@string/choice_intro"
	android:textStyle="italic" />

Fügen Sie die hier angegebene String-Ressource zu Ihrer Datei "strings.xml" hinzu. Stellen Sie dabei sicher, dass Sie sie in beide Kopien der String-Datei in "values" und "values-v14" aufnehmen:

1	<string name="choice_intro">Choose an option:</string>

Jetzt zeigen wir ein Bild an, um jedes Uhrendesign darzustellen. Diese Bilder dienen als Schaltflächen, die Benutzer bei der Auswahl eines Designs drücken können. Erstellen Sie jetzt Ihre Bilder und denken Sie daran, für jede Dichte unterschiedliche Versionen einzuschließen. Wenn Sie noch keine eigenen erstellen möchten, können Sie die Bilder im Download-Link unten im Tutorial verwenden. Hier sind die Versionen mit mittlerer Dichte:

Speichern Sie jede Version Ihrer Bilder in den Zeichenordnern für Ihre App, und denken Sie daan, in jedem Dichteordner dieselben Namen zu verwenden.

Kehren Sie nun zu Ihrer XML-Layoutdatei "clock_choice" zurück. Fügen Sie für jedes verwendete Design eine Bildschaltfläche hinzu. Für die drei von uns verwendeten Beispieldesigns nach der Textansicht gilt Folgendes:

<ImageButton
	android:id="@+id/design_0"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:src="@drawable/clock_image"
	android:contentDescription="@string/design1"
	android:background="#00000000"
	android:padding="5dp"/>
<ImageButton
	android:id="@+id/design_1"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:src="@drawable/clock_image_stone"
	android:contentDescription="@string/design2"
	android:background="#00000000"
	android:padding="5dp"/>
<ImageButton
	android:id="@+id/design_2"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:src="@drawable/clock_image_metal"
	android:contentDescription="@string/design3"
	android:background="#00000000"
	android:padding="5dp" />

Hier sind einige Punkte zu beachten. Beachten Sie zunächst, dass jede Bildschaltfläche eine ID mit derselben Syntax, aber einer inkrementierenden Ganzzahl am Ende hat. Wir werden diese verwenden, um die Designs in Java zu durchlaufen. Wenn Sie also mehr als drei Designs einschließen, stellen Sie sicher, dass Sie sie iterativ zuweisen Zahlen wie "design_3" usw. Abgesehen von den Designattributen gibt jedes Element auch die relevante zeichnbare Ressource an. Ändern Sie diese also, wenn die gerade erstellten Bilddateien unterschiedliche Namen haben. Schließlich beziehen sich die Inhaltsbeschreibungsattribute auf Zeichenfolgenressourcen. Fügen Sie sie daher wie folgt zu den Dateien "strings.xml" in Ihren Ordnern "values" und "values-v14" hinzu:

1	<string name="design1">Default design</string>
2	<string name="design2">Stone design</string>
3	<string name="design3">Metal design</string>

Ändern Sie diese Beschreibungen gegebenenfalls entsprechend Ihren eigenen Designs.

Verwenden wir Android-Designs, um bestimmte Aspekte des Erscheinungsbilds der ausgewählten Aktivität zu automatisieren. Öffnen Sie die Manifestdatei Ihres Projekts und erweitern Sie das Element, das die Aktivität der Uhrauswahl darstellt, wie folgt:

1	<activity android:name=".ClockChoice" android:theme="@android:style/Theme.Dialog">
2	</activity>

Durch Hinzufügen des DialogThemes wird die Aktivität auf dem Startbildschirm überlagert angezeigt. Dies ist das Erscheinungsbild der Beispieldesigns, die wir in dieser Lernserie verwendet haben:

Dies wird angezeigt, wenn der Benutzer auf das Widget klickt. Wenn die Geräteanzeige zu klein ist, um alle drei Designs aufzunehmen, werden sie gescrollt, da das Layout eine Bildlaufansicht verwendet. Wenn der Benutzer ein Design auswählt, wird das Erscheinungsbild des Widgets aktualisiert und diese Auswahlaktivität verschwindet.

Es versteht sich von selbst, dass Sie möglicherweise die Anzahl der möglichen Designs in Ihrer Uhr-Widget-App ändern möchten. Um diesen Prozess zu vereinfachen, lassen wir unseren Java-Code die Anzahl der Designs dynamisch lesen. Zu diesem Zweck verwenden wir einen numerischen Wert, um die Anzahl der von uns verwendeten Designs zu verfolgen. Erstellen Sie eine neue Datei in jedem Ihrer beiden Werteordner, klicken Sie mit der rechten Maustaste oder wählen Sie nacheinander jeden Ordner aus und wählen Sie "Datei", dann "Neu", "Datei" und geben Sie "numbers.xml" als Dateinamen ein.

Wählen Sie die Registerkarte "numbers.xml" und geben Sie den folgenden Code in Ihre neue Datei ein:

1	<resources>
2	<integer name="num_clocks">3</integer>
3	</resources>

Ändern Sie die Anzahl, wenn Sie eine andere Anzahl von Designs verwendet haben, und stellen Sie sicher, dass der Wert mit der Anzahl der Bildschaltflächen übereinstimmt, die Sie in das Layout aufgenommen haben, und der Anzahl der Analoguhrelemente, die Sie in Ihrem Widget-Layout haben. Denken Sie daran, dass Sie in beiden Werteordnern eine Kopie der Datei "numbers.xml" benötigen. Kopieren Sie sie daher und fügen Sie sie gegebenenfalls ein.

Wenn Sie die Anzahl der verwendeten Designs zu einem beliebigen Zeitpunkt ändern, müssen Sie den Wert in den Dateien "numbers.xml" ändern, jedes Design als analoges Uhrelement in die Datei "clock_widget_layout" der App einfügen und eine Bildschaltfläche für jedes Design in der ausgewählten Aktivitätslayoutdatei.

Schritt 4: Benutzerauswahl handhaben

Lassen Sie uns die Benutzerinteraktion mit der Auswahl der Uhrendesigns behandeln. Öffnen Sie Ihre Aktivitätsdatei "ClockChoice". Fügen Sie innerhalb der Klasse vor der Methode "onCreate" die folgenden Instanzvariablen hinzu:

//count of designs
private int numDesigns;
//image buttons for each design
private ImageButton[] designBtns;
//identifiers for each clock element
private int[] designs;

Wir werden diese Variablen verwenden, um die verschiedenen Designs zu durchlaufen. Fügen Sie einen weiteren Import hinzu:

1	import android.widget.ImageButton;

Instanziieren Sie innerhalb der "onCreate" -Methode nach dem vorhandenen Code die Variable, um die Anzahl der Uhrendesigns wie folgt zu verfolgen:

1	numDesigns = this.getResources().getInteger(R.integer.num_clocks);

Hier rufen wir den Wert in der zuvor erstellten Zahlen-XML-Datei ab. Wir können diesen Wert als Referenz verwenden, wenn wir die Entwürfe durchlaufen. Weiter instanziieren Sie die Arrays für die Design-Schaltflächen und Uhrenelemente:

1	designBtns = new ImageButton[numDesigns];
2	designs = new int[numDesigns];

Das erste Array bezieht sich auf die Bildschaltflächen, die wir in dieser Auswahlaktivität verwenden, um die Auswahl de Benutzers zu ermitteln. Das zweite Array speichert Verweise auf die Analog Clock-Elemente für jedes Design in der Widget-Layoutdatei.

Fügen Sie nun eine Schleife hinzu, um die Designs zu durchlaufen:

1	for(int d=0; d<numDesigns; d++){
2
3	}

Rufen Sie innerhalb der Schleife einen Verweis auf jedes Analog Clock-Element im Widget-Layout ab:

1	designs[d] = this.getResources().getIdentifier
2	("AnalogClock"+d, "id", getPackageName());

Wenn Sie auf die Datei "clock_widget_layout" zurückblicken, werden Sie feststellen, dass jedes Analog Clock-Element eine ID mit "AnalogClock" gefolgt von einer inkrementierenden Ganzzahl hat. Wir verwenden diese hier, um mithilfe des Schleifenzählers einen Verweis auf jedes Element abzurufen. Rufen Sie dann noch innerhalb der Schleife die ID-Werte für die Bildschaltflächen im ausgewählten Aktivitätslayout ab:

1	designBtns[d]=(ImageButton)findViewById(this.getResources().getIdentifier
2	("design_"+d, "id", getPackageName()));

Hier verwenden wir "findViewById", um einen Verweis auf das relevante Image Button-Element zu erhalten, wobei die ID übergeben wird, die "design_" gefolgt von der inkrementierenden Ganzzahl enthält. Stellen Sie nun den Klick-Listener für jede dieser Schaltflächen so ein, dass wir Klicks in dieser Aktivitätsklasse verarbeiten können. Noch in der Schleife:

1	designBtns[d].setOnClickListener(this);

Jetzt können wir mit der Klickmethode für die Entwurfsschaltflächen fortfahren. Fügen Sie nach der "onCreate" -Methode in der "ClockChoice" -Klasse eine "onClick" -Methode wie folgt hinzu:

1	public void onClick(View v) {
2
3	}

Fügen Sie den folgenden Import hinzu:

1	import android.view.View;

Bei der "onClick" -Methode müssen wir zunächst feststellen, welche Schaltfläche der Benutzer gedrückt hat. Fügen Sie zu diesem Zweck die folgende Schleife in die Methode ein:

int picked = -1;
for(int c=0; c<numDesigns; c++){
	if(v.getId()==designBtns[c].getId()){
		picked=c;
		break;
	}
}

Hier überprüfen wir die angeklickte Ansichts-ID mit den IDs, die wir im Image Button-Array gespeichert haben. Wenn die Schleife beendet wird, wird der ausgewählte Index in einer lokalen Variablen gespeichert. Speichern Sie nach der Schleife einen Verweis auf die ID für das ausgewählte Analog Clock-Element:

1	int pickedClock = designs[picked];

Jetzt müssen wir einen Verweis auf die Widget-Layout-Elemente erhalten, für die wir die Remote-Ansichten benötigen, und das Widget-Layout als Referenz übergeben:

1	RemoteViews remoteViews = new RemoteViews
2	(this.getApplicationContext().getPackageName(),
3	R.layout.clock_widget_layout);

Dazu benötigen Sie eine weitere Importanweisung:

1	import android.widget.RemoteViews;

Denken Sie daran, dass wir jedes Analoguhr-Design in die Widget-Layoutdatei aufgenommen haben. Dies liegt daran, dass wir die Attribute einer Analoguhr wie die Zeichen für das Zifferblatt und die Zeiger nicht dynamisch ändern können. Stattdessen nehmen wir alle Designs auf und stellen ale ein aber einer, der unsichtbar ist. Bevor wir das gewählte Uhrendesign sichtbar machen, setzen wir die anderen unsichtbar, was wir in einer Schleife wie folgt tun können:

1	for(int d=0; d<designs.length; d++){
2	if(d!=pickedClock)
3	remoteViews.setViewVisibility(designs[d], View.INVISIBLE);
4	}

Wir verwenden das Array, in dem wir die Analog Clock-Element-ID-Werte gespeichert haben, um jedes unsichtbar zu machen, solange es nicht das ausgewählte ist. Jetzt können wir das ausgewählte Design nach dieser Schleife so einstellen, dass es sichtbar ist:

1	remoteViews.setViewVisibility(pickedClock, View.VISIBLE);

Da es sich um eine Widget-App handelt, müssen wir das Erscheinungsbild des Widgets wie folgt aktualisieren:

//get component name for widget class
ComponentName comp = new ComponentName(this, ClockWidget.class);
//get AppWidgetManager
AppWidgetManager appWidgetManager = 
	AppWidgetManager.getInstance(this.getApplicationContext());
//update
appWidgetManager.updateAppWidget(comp, remoteViews);

Dies ähnelt der Art und Weise, wie wir das Widget in der Widget-Provider-Klasse aktualisiert haben, jedoch mit einigen zusätzlichen Verarbeitungsschritten, da wir uns hier in einer Activity-Klasse befinden. Sie müssen diese Importe hinzufügen:

1	import android.appwidget.AppWidgetManager;
2	import android.content.ComponentName;

Jetzt wird das Erscheinungsbild des Widgets entsprechend der Auswahl des Benutzers aktualisiert.

Schritt 5: Gemeinsame Einstellungen aktualisieren

Dann verwenden wir die gemeinsamen Einstellungen der Anwendung, um die Auswahl des Benutzerdesigns zu speichern. Sichern Sie oben in der Aktivitätsklasse "Clock Choice" eine weitere Instanzvariable:

1	private SharedPreferences clockPrefs;

Fügen Sie nun am Ende der "onCreate" -Methode nach dem vorhandenen Code Folgendes hinzu, um die Variable "Gemeinsame Einstellungen" zu instanziieren:

1	clockPrefs = getSharedPreferences("CustomClockPrefs", 0);

Bei jedem Zugriff auf die Daten nach Wahl des Benutzers wird derselbe Voreinstellungsname verwendet. Gehen Sie nun nach dem Code, in dem wir das Widget aktualisiert haben, zum Ende der "onClick" -Methode. Rufen Sie den Einstellungseditor wie folgt auf:

1	SharedPreferences.Editor custClockEdit = clockPrefs.edit();

Übergeben Sie nun die Daten zur Benutzerauswahl an den Editor und legen Sie sie fest:

1	custClockEdit.putInt("clockdesign", picked);
2	custClockEdit.commit();

Wir geben einen Namen für den Datenwert und die ID des ausgewählten Designs an. Fügen Sie schließlich noch in "onClick" Folgendes hinzu, wenn die Aufgabe erledigt ist:

finish();

Schritt 6: Überprüfen Sie die freigegebenen Einstellungen

Jetzt können wir die Shared Preferences-Daten aus der Widget-Klasse heraus verwenden. Öffnen Sie Ihre "ClockWidget" - Klasse, die AppWidgetProvider erweitert. Die hier verwendeten Algorithmen ähneln denen, die wir oben für die Verwaltung der Uhrendesigns verwendet haben. Fügen Sie oben die folgenden zusätzlichen Instanzvariablen hinzu:

//preferences
private SharedPreferences custClockPrefs;
//number of possible designs
private int numClocks;
//IDs of Analog Clock elements
int[] clockDesigns;

Sie benötigen folgenden Import:

1	import android.content.SharedPreferences;

Rufen Sie in der Methode "onReceive" vor dem vorhandenen Code die Anzahl der Designs aus unserer Wertressource ab:

1	numClocks = context.getResources().getInteger(R.integer.num_clocks);

Dann instanziieren Sie das Clock-ID-Array wie unten:

1	clockDesigns = new int[numClocks];

Durchlaufen Sie nun dieses Array und legen Sie jedes Element als ID für das entsprechende Analog Clock-Element im Widget-Layout fest:

1	for(int d=0; d<numClocks; d++){
2	clockDesigns[d]=context.getResources().getIdentifier
3	("AnalogClock"+d, "id", context.getPackageName());
4	}

Wechseln Sie nun zum Inhalt der "if" -Anweisung in der "onReceive" - Methode, rufen Sie nach der Zeile, in der wir die Remote-Ansichten abgerufen haben, und vor der Zeile, in der wir die Absicht für die Clock-Auswahlklasse erstellt haben, die gemeinsamen Einstellungen ab und überprüfen Sie sie für den Datenwert, den wir nach Wahl des Benutzers festlegen:

1	custClockPrefs = context.getSharedPreferences("CustomClockPrefs", 0);
2	int chosenDesign = custClockPrefs.getInt("clockdesign", -1);

Der Name der freigegebenen Einstellungen und der Name des Datenwerts müssen mit dem übereinstimmen, den Sie beim Festlegen der Benutzerauswahl in der Auswahlaktivität oben angegeben haben. Der Benutzer hat möglicherweise noch kein Design ausgewählt. Fügen Sie daher eine "if" -Anweisung ein, um Folgendes zu überprüfen:

1	if(chosenDesign>=0){
2
3	}

Durchlaufen Sie in der "if" -Anweisung zunächst die Designs und setzen Sie jedes unsichtbar, wenn es nicht das ausgewählte ist:

1	for(int d=0; d<numClocks; d++){
2	if(d!=chosenDesign)
3	views.setViewVisibility(clockDesigns[d], View.INVISIBLE);
4	}

Sie benötigen einen weiteren Import:

1	import android.view.View;

Stellen Sie nun das gewählte Design sichtbar:

1	views.setViewVisibility(clockDesigns[chosenDesign], View.VISIBLE);

Wenn das Widget aktualisiert wird und der Benutzer ein Design ausgewählt hat, wird dieses Design angezeigt.

Schlussfolgerung

Das ist das fertige Uhr-Widget! Sie können es auf einem Emulator oder Gerät ausführen, um es zu testen. Es sollte kontinuierlich ausgeführt werden, die Zeit aktualisieren und die Designauswahl des Benutzers widerspiegeln.

Nehmen Sie sich etwas Zeit, um einen Blick auf die verschiedenen Anwendungselemente zu werfen und sicherzustellen, dass Sie verstehen, wie sie zusammenarbeiten. Der Prozess der Entwicklung einer anderen Widget-App umfasst viele der gleichen Schritte. Die wichtigsten Elemente in einer Widget-App sind: das XML-Element "appwidget-provider", die Manifest-Datei, die Klasse, die AppWidgetProvider erweitert, und natürlich die visuellen Elemente, einschließlich Layouts und Ressourcen.

Wenn Sie die Fähigkeiten, die Sie in dieser Serie gelernt haben, weiterentwickeln möchten, gibt es eine Reihe von Optionen. Wenn Sie eine erweiterte Benutzerkonfiguration für Ihre Widgets bereitstellen möchten, können Sie eine Voreinstellungsaktivität zusammen mit der Aktion APPWIDGET_CONFIGURE verwenden. Wenn Sie digitale Uhranzeigen zusammen mit Ihren analogen Optioen einbinden möchten, ist der Vorgang etwas komplexer. Sie können die Standard-Digitaluhrklasse in eine Standard-App aufnehmen, jedoch nicht in eine Widget-App. Daher müssen Sie die digitale Zeitanzeige implementieren und selbst aktualisieren, indem Sie zusätzliche Komponenten wie Dienste und Alarmmanager verwenden.

Sie können gerne den vollständigen Quellcode und die Bilder für dieses Tutorial verwenden, die Sie im Download-Link finden.