Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Android SDK

Holen Sie sich Wear OS und Android Talking: Austausch von Informationen über die Wearable Data Layer

by
Read Time:19 minsLanguages:

German (Deutsch) translation by Tatsiana Bochkareva (you can also view the original English article)

Wenn es darum geht, schnelle und einfache Aufgaben zu erledigen, haben Wearable-Apps den Vorteil, dass eine Smartwatch direkt am Handgelenk immer zugänglicher ist als ein Smartphone oder Tablet, das irgendwo in der Tasche herumschwebt.

Aber das perfekte Gadget gibt es nicht, und niemand schwärmt von der Akkulaufzeit seiner Smartwatch oder behauptet, dass sie genauso schnell und leistungsstark ist wie ihr Smartphone oder Tablet.

Um die bestmögliche Benutzererfahrung zu bieten, müssen Sie die Stärken eines Geräts ausspielen. Wenn Sie für Wear OS (das früher als Android-Wear bekannte Betriebssystem) entwickeln, sind Sie in der einzigartigen Position, die besten Funktionen von zwei sehr unterschiedlichen Geräten auszuwählen.

Grundsätzlich können Sie das Beste aus beiden Welten haben!

In diesem Artikel zeige ich Ihnen, wie Sie das Beste aus allem herausholen, was Android OS und Wear OS zu bieten haben, indem Sie einen Kommunikationskanal zwischen den beiden öffnen. Sobald Ihre Handheld-App und ihr tragbares Gegenstück chatten, können Sie Aufgaben basierend auf dem Gerät delegieren, für das sie am besten geeignet ist – ob Sie batterieintensive Aufgaben auf das Handheld übertragen oder sicherstellen, dass die wichtigsten Informationen Ihrer App immer leicht zugänglich sind, indem sie angezeigt werden am Handgelenk des Benutzers.

Am Ende dieses Artikels haben Sie einen Handheld und eine Wearable-Anwendung erstellt, die Informationen über den Wearable Data Layer und die MessageClient-API austauschen können.

Was ist die tragbare Datenschicht?

Der Wearable Data Layer bietet Zugriff auf verschiedene Client-Klassen, mit denen Sie Daten speichern und abrufen können, ohne sich mit technischen Details wie der Datenserialisierung die Hände schmutzig machen zu müssen. Sobald sich diese Informationen auf der Datenschicht befinden, sind sie sowohl für das Handheld als auch für das tragbare Gerät zugänglich.

In diesem Artikel konzentrieren wir uns auf die MessageClient-API, bei der es sich um einen unidirektionalen Kommunikationsmechanismus handelt, mit dem Sie Informationen an die Wearable Data Layer senden können. Diese API ist besonders praktisch für die Ausführung von Remote Procedure Calls (RPC), z. B. das Starten einer Activity aus der Ferne auf dem gekoppelten Handheld oder tragbaren Gerät.

Schauen wir uns ein Beispiel an: Stellen Sie sich vor, Sie haben eine Navigations-App erstellt. Diese App muss a) Standortaktualisierungen abrufen und b) dem Benutzer Anweisungen geben.

Die Überwachung des Gerätestandorts ist eine intensive Aufgabe, die die begrenzte Batterie Ihres typischen Wearables schnell entladen kann. Mithilfe der MessageClient-API kann Ihre Wearable-App ihr Handheld-Gegenstück anweisen, diese Arbeit stattdessen auszuführen. Sobald das Handheld diese schwere Arbeit erledigt hat, kann es die resultierenden Informationen über die Datenschicht an das Wearable zurücksenden, sodass Ihre App die benötigten Informationen erhält, ohne den verbleibenden Akku des Wearables zu entlasten.

Wenn Ihre Wearable-App eine Aufgabe ausführen muss, die viel Akku- oder Rechenleistung oder komplexe Benutzerinteraktionen erfordert, sollten Sie in der Regel erwägen, diese Arbeit auf die entsprechende Handheld-App auszulagern. Handelt es sich bei Ihrer App hingegen um besonders zeitkritische Informationen oder Inhalte, auf die der Nutzer voraussichtlich unterwegs zugreifen wird, sollten Sie diese Informationen auf der Wearable-App anzeigen.

In unserem Navigations-App-Beispiel macht das Verschieben jedes Satzes von Wegbeschreibungen vom Handheld auf das Wearable diese Informationen leichter zugänglich, insbesondere für jemanden, der unterwegs ist und sich hoffnungslos verirrt hat!

Die MessageClient-API ist standardmäßig ein unidirektionaler Kommunikationsmechanismus, aber Sie können bidirektionales Messaging implementieren, indem Sie sowohl im Handheld- als auch im Wearable-Modul Ihres Projekts einen Sender und einen Empfänger erstellen – und genau das werden wir tun.

Erstellen eines Wearable- und eines Handheld-Moduls

In diesem Artikel werden wir eine tragbare App erstellen, die erkennt, wenn ihr Handheld-Gegenstück eine neue Nachricht an die Datenschicht sendet. Diese tragbare App antwortet dann, indem sie diese Nachricht abruft und als Teil ihrer Benutzeroberfläche anzeigt.

Dann spülen und wiederholen wir und erstellen eine Handheld-App, die die Datenschicht auf Nachrichten überwacht, die von ihrem tragbaren Gegenstück gesendet werden.

Über die MessageClient-API gesendete Informationen sind nur für die Anwendung zugänglich, die sie erstellt hat. Wenn das System erkennt, dass Ihr Wearable und Ihr Handheld zu derselben Anwendung gehören, müssen sie denselben Paketnamen, denselben Versionscode und dasselbe Signaturzertifikat haben. Der einfachste Weg, all diese Kästchen anzukreuzen, besteht darin, ein Projekt zu erstellen, das sowohl aus einem tragbaren als auch einem Handheld-Modul besteht:

  • Erstellen Sie ein neues Projekt namens DataLayer.
  • Wählen Sie auf dem Bildschirm Ziel-Android-Gerät Telefon und Tablet und Wear aus. Klicken Sie Weiter.
  • Wählen Sie für Ihr Telefon- und Tablet-Modul die Vorlage Leere Aktivität aus, und klicken Sie dann auf Weiter.
  • Wählen Sie für Ihr Wearable-Modul die Vorlage Blank Wear Activity aus und klicken Sie dann auf Weiter und anschließend auf Fertig stellen.

Erstellen Ihrer Handheld-App

Da wir bidirektionale Kommunikation implementieren, benötigen sowohl unser Handheld als auch unsere mobilen Module einen eigenen Hörer und Sender. Beginnen wir mit der Implementierung dieser Funktionalität in unsere Handheld-Anwendung.

Ich werde die Dinge einfach halten und eine Benutzeroberfläche erstellen, die aus einer TextView besteht, die die verschiedenen Nachrichten anzeigt, die aus der Datenschicht abgerufen wurden, und einer Schaltfläche, die beim Antippen eine eigene Nachricht an die Datenschicht sendet.

Öffnen Sie die Datei activity_main.xml Ihres mobilen Moduls und fügen Sie Folgendes hinzu:

Da wir auf einige dimens.xml-Werte verwiesen haben, müssen wir Definitionen für diese Werte bereitstellen:

  • Klicken Sie bei gedrückter Ctrl-Taste auf das Verzeichnis res/values ​​des mobilen Moduls.
  • Wählen Sie Neu > Werteressourcendatei aus.
  • Benennen Sie diese Datei dimens.xml und klicken Sie dann auf OK.
  • Fügen Sie Folgendes hinzu:

Dadurch erhalten wir folgende Benutzeroberfläche:

Create the user interface for your projects handheld componentCreate the user interface for your projects handheld componentCreate the user interface for your projects handheld component

Fügen Sie Ihre Abhängigkeiten hinzu

Öffnen Sie die Datei build.gradle des mobilen Moduls und fügen Sie die folgenden Abhängigkeiten hinzu:

Anzeigen und Senden von Nachrichten in MainActivity

In MainActivity müssen wir Folgendes ausführen:

  1. Halten Sie den Benutzer auf dem Laufenden!

Wenn der Benutzer auf die Schaltfläche Mit dem Wearable sprechen tippt, müssen zwei Dinge passieren:

  • Das Handheld sendet eine Nachricht an das Wearable. Ich verwende "Ich habe eine Nachricht vom Handheld erhalten".
  • Das Handheld bestätigt visuell, dass die Nachricht erfolgreich gesendet wurde. Ich werde "Ich habe eine Nachricht an das Wearable gesendet" verwenden.

Wenn der Benutzer auf die Schaltfläche „Mit dem Wearable sprechen“ des Handhelds tippt, versucht das Handheld, eine Nachricht an die Datenschicht zu senden. Das System betrachtet diese Nachricht erst dann als erfolgreich gesendet, wenn sie für die Zustellung an ein bestimmtes Gerät in die Warteschlange gestellt wurde, was bedeutet, dass mindestens ein gekoppeltes Gerät verfügbar sein muss.

Im besten Fall tippt der Benutzer auf Mit dem Wearable sprechen, die Nachricht wird in die Warteschlange für die Zustellung gestellt und unser Handheld erklärt triumphierend: "Ich habe gerade eine Nachricht an das Wearable gesendet."

Wenn jedoch keine tragbaren Geräte verfügbar sind, wird die Nachricht nicht in die Warteschlange gestellt und der Benutzer erhält standardmäßig keine Bestätigung, dass unsere App überhaupt versucht hat, eine Nachricht zu senden. Dies könnte dazu führen, dass sich der Benutzer fragt, ob die App defekt ist, daher werde ich auch eine Sendenachricht anzeigen…. Benachrichtigung, unabhängig davon, ob die Nachricht erfolgreich in die Warteschlange gestellt wurde oder nicht.

Beim Testen dieser App möchten Sie möglicherweise auch mehrere Nachrichten kurz hintereinander auslösen. Um zu verdeutlichen, wann jede Nachricht für die Zustellung in die Warteschlange eingereiht wurde, füge ich jeder Nachricht einen Zähler hinzu, damit unser Handheld anzeigt, dass ich gerade eine Nachricht an das Wearable 2 gesendet habe, ich habe gerade eine Nachricht an das Wearable 3 gesendet, und so An. Auf der anderen Seite der Verbindung zeigt unser Wearable an, dass ich gerade eine Nachricht vom Handheld 2 erhalten habe, ich habe gerade eine Nachricht vom Handheld 3 erhalten usw.

2. Erhaltene Nachrichten anzeigen

Im nächsten Abschnitt erstellen wir einen MessageService, der die Datenschicht überwacht und Nachrichten abruft. Da unser Dienst seine Arbeit in einem anderen Thread verrichtet, sendet er diese Informationen an unsere MainActivity, die dann für die Aktualisierung der Benutzeroberfläche verantwortlich ist.

3. Definieren Sie den Pfad

Jede Nachricht, die Sie über die MessageClient-API übertragen, muss einen Pfad enthalten, bei dem es sich um eine Zeichenfolge handelt, die die Nachricht eindeutig identifiziert und es Ihrer App ermöglicht, von der anderen Seite der Verbindung darauf zuzugreifen.

Dieser Pfad beginnt immer mit einem Schrägstrich (ich verwende /my_path) und kann auch eine optionale Nutzlast in Form eines Byte-Arrays enthalten.

4. Überprüfen Sie Ihre Knoten!

In den Google Play-Diensten 7.3.0 und höher können Sie mehrere Wearables mit einem einzigen Handheld-Gerät verbinden. Beispielsweise könnte ein Nutzer mehrere Wearables verwenden, zwischen denen er wechselt oder die er gleichzeitig verwendet. Ein Wear OS-Gerät kann während seiner Lebensdauer auch mit mehreren Handheld-Geräten verbunden sein, beispielsweise wenn der Benutzer ein Android-Smartphone und ein Tablet besitzt oder sein altes Smartphone durch ein glänzendes neues ersetzt. Beachten Sie, dass jedes Gerät, das eine Verbindung zur Datenschicht herstellen kann, im Anwendungscode als Knoten bezeichnet wird.

In diesem Artikel gehe ich davon aus, dass es immer nur ein einziges verfügbares Wearable geben wird. Alternativ können Sie mit GetConnectedNodes oder getLocalNode auswählen, an welche Geräte Sie Nachrichten senden.

Lassen Sie uns all dies in unserer MainActivity implementieren:

Erstellen Sie einen Abhördienst

Zu diesem Zeitpunkt ist unser Handheld in der Lage, Nachrichten an die Datenschicht zu senden, aber da wir eine bidirektionale Kommunikation implementieren möchten, muss es auch auf Nachrichten warten, die auf der Datenschicht eintreffen.

In diesem Abschnitt erstellen wir einen Dienst, der Folgendes ausführt:

  1. Überwachen Sie die Datenschicht auf Ereignisse

Sie können die Datenschicht überwachen, indem Sie entweder die Schnittstelle DataClient.OnDataChangedListener implementieren oder den WearableListenerService erweitern. Ich entscheide mich für Letzteres, da die Erweiterung des WearableListenerService einige Vorteile bietet. Erstens erledigt WearableListenerService seine Arbeit in einem Hintergrundthread, sodass Sie sich keine Sorgen machen müssen, den Haupt-UI-Thread zu blockieren. Zweitens verwaltet das System den WearableListenerService-Lebenszyklus, um sicherzustellen, dass keine unnötigen Ressourcen verbraucht werden, und bindet und entbindet den Dienst nach Bedarf.

Der Nachteil besteht darin, dass WearableListenerService auch dann auf Ereignisse lauscht, wenn Ihre Anwendung nicht ausgeführt wird, und Ihre Anwendung startet, wenn ein relevantes Ereignis erkannt wird. Wenn Ihre App nur auf Ereignisse reagieren muss, wenn sie bereits ausgeführt wird, kann WearableListenerService den Akku des Geräts unnötig entladen.

2. Überschreiben Sie die relevanten Datenrückrufe

WearableListenerService kann auf eine Reihe von Datenschichtereignissen lauschen, sodass Sie die Rückrufmethoden für Datenereignisse für die Ereignisse, die Sie bearbeiten möchten, überschreiben müssen. In unserem Service implementiere ich onMessageReceived, das ausgelöst wird, wenn eine Nachricht vom Remote-Knoten gesendet wird.

3. Überprüfen Sie den Pfad

Jedes Mal, wenn eine Nachricht an die Datenschicht gesendet wird, muss unsere App überprüfen, ob sie die richtige my_path-Kennung hat.

4. Nachrichten an MainActivity senden

Da WearableListenerService in einem anderen Thread ausgeführt wird, kann die Benutzeroberfläche nicht direkt aktualisiert werden. Um eine Nachricht in unserer Anwendung anzuzeigen, müssen wir sie mit einem LocalBroadcastManager an MainActivity weiterleiten.

So erstellen Sie den Dienst:

  • Stellen Sie sicher, dass Sie das mobile Modul ausgewählt haben.
  • Wählen Sie in der Android Studio-Symbolleiste Neu > Dienst aus.
  • Nennen Sie diesen Dienst MessageService.
  • Fügen Sie Folgendes hinzu:

Öffnen Sie schließlich das Manifest und fügen Sie dem MessageService-Eintrag einige Informationen hinzu:

Wie bereits erwähnt, betrachtet das System eine Nachricht erst dann als erfolgreich gesendet, wenn sie zur Zustellung in die Warteschlange gestellt wurde, was nur erfolgen kann, wenn ein oder mehrere Wearables verfügbar sind.

Sie können dies in Aktion sehen, indem Sie das mobile Modul auf einem kompatiblen Smartphone oder Tablet oder einem Android Virtual Device (AVD) installieren. Klicken Sie auf die Schaltfläche Mit dem Wearable sprechen und die App zeigt nur den Text Nachricht senden… an. Der Text, den ich gerade gesendet habe, wird nicht angezeigt.

Wenn unsere Nachricht jemals zur Zustellung in die Warteschlange gestellt wird, müssen wir einen weiteren Satz von Sender- und Empfängerkomponenten im Wearable-Modul unseres Projekts implementieren.

Erstellen Sie Ihre tragbare App

Unsere Wearable-App wird ähnliche Funktionen wie ihr Handheld-Pendant haben, daher überspringe ich den gesamten Code, den wir bereits behandelt haben.

Beginnen wir noch einmal mit der Erstellung der Benutzeroberfläche der App. Öffnen Sie die Datei activity_main.xml des Wear-Moduls und fügen Sie Folgendes hinzu:

An dieser Stelle sollte Ihre Benutzeroberfläche etwa so aussehen:

Create the UI for your Android projects Wear OS module Create the UI for your Android projects Wear OS module Create the UI for your Android projects Wear OS module

Öffnen Sie Ihre build.gradle und fügen Sie die folgenden Abhängigkeiten hinzu:

Jetzt müssen wir unsere Nachricht an die Datenschicht senden:

Als Nächstes müssen wir einen Listener erstellen, der die Datenschicht auf eingehende Nachrichten überwacht und MainActivity benachrichtigt, wenn eine neue Nachricht empfangen wird:

  • Stellen Sie sicher, dass das wear-Modul ausgewählt ist.
  • Wählen Sie Neu > Dienst aus der Android Studio-Symbolleiste.
  • Benennen Sie diesen Dienst MessageService und fügen Sie dann Folgendes hinzu:

Öffnen Sie das Manifest des Moduls und erstellen Sie einen Intent-Filter für den WearableListenerService:

Sie können das komplette Projekt von GitHub herunterladen.

Testen Ihrer App

An dieser Stelle haben Sie zwei Apps, die Nachrichten über die Datenschicht austauschen können, aber wenn Sie diese Kommunikationsfähigkeiten auf die Probe stellen möchten, müssen Sie Ihr Projekt auf einem Handheld und einem tragbaren Gerät installieren.

Wenn Sie ein Android-Entwickler sind, haben Sie wahrscheinlich mindestens ein Android-Smartphone oder -Tablet herumliegen, aber Wearables fühlen sich immer noch wie ein relativ neues Nischenprodukt an, sodass Sie möglicherweise noch nicht in eine Smartwatch investiert haben.

Wenn Sie sich für die Entwicklung von Wear OS entscheiden, sollten Sie irgendwann den Sprung wagen und eine Smartwatch kaufen, da es keinen Ersatz dafür gibt, Ihre App auf einem echten Android-Gerät zu testen. Wenn Sie jedoch nur mit Wear OS experimentieren, können Sie ein AVD erstellen, das ein Wearable emuliert, genauso wie Sie ein AVD erstellen, das ein Smartphone oder Tablet emuliert. Sie können dann Ihr AVD und Ihr physisches Android-Gerät mithilfe der Portweiterleitung zum Sprechen bringen.

Der erste Schritt besteht darin, ein tragbares AVD zu erstellen und Ihr Wear-Modul auf diesem emulierten Gerät zu installieren:

  • Wählen Sie Tools > Android > AVD Manager aus der Android Studio-Symbolleiste.
  • Klicken Sie auf Virtuelles Gerät erstellen…
  • Wählen Sie im Menü auf der linken Seite die Option Wear aus.
  • Wählen Sie das Wearable aus, das Sie emulieren möchten, und klicken Sie dann auf Weiter.
  • Wählen Sie Ihr Systemabbild aus, und klicken Sie dann auf Weiter.
  • Geben Sie Ihrem AVD einen Namen und klicken Sie dann auf Fertig stellen.
  • Wählen Sie Ausführen > Ausführen… aus der Android Studio-Symbolleiste.
  • Wählen Sie in dem kleinen Popup, das angezeigt wird, Wear…
  • Wählen Sie das gerade erstellte Wearable-AVD aus. Nach wenigen Augenblicken startet AVD mit Ihrer bereits installierten Wearable-Komponente.

Installieren Sie als Nächstes das Handheld-Modul auf Ihrem Smartphone oder Tablet:

  • Verbinden Sie Ihr physisches Android-Gerät mit Ihrem Entwicklungscomputer.
  • Wählen Sie Ausführen > Ausführen… aus der Android Studio-Symbolleiste.
  • Wählen Sie mobile, wenn Sie dazu aufgefordert werden.

Schließlich müssen wir unser physisches Android-Gerät und unseren AVD zum Sprechen bringen:

  • Stellen Sie sicher, dass Bluetooth auf Ihrem Handheld aktiviert ist (Einstellungen > Bluetooth) und dass es über ein USB-Kabel mit Ihrem Entwicklungscomputer verbunden ist.
  • Öffnen Sie auf Ihrem Handheld-Gerät den Play Store und laden Sie die Wear OS by Google-App (ehemals Android Wear) herunter.
  • Starten Sie die Wear OS-Anwendung.
  • Klicken Sie auf Ihrem emulierten Wearable auf die Home-Schaltfläche in der zugehörigen Schaltflächenleiste (wo sich der Cursor im folgenden Screenshot befindet) und öffnen Sie dann die App Einstellungen.

Testing your project by connecting your emulator and your Android smartphone or tabletTesting your project by connecting your emulator and your Android smartphone or tabletTesting your project by connecting your emulator and your Android smartphone or tablet

  • Wählen Sie System > Info und klicken Sie wiederholt auf die Build-Nummer, bis Sie die Meldung Sie sind jetzt ein Entwickler sehen.
  • Kehren Sie zum Hauptmenü Einstellungen zurück, indem Sie zweimal auf die Schaltfläche Zurück klicken. Sie sollten ein neues Element der Entwickleroptionen bemerken; gib ihm einen klick.
  • Wählen Sie ADB-Debugging aus.
  • Öffnen Sie auf Ihrem Entwicklungscomputer eine neue Eingabeaufforderung (Windows) oder Terminal (Mac) und ändern Sie dann das Verzeichnis (cd), sodass es auf den Plattform-Tools-Ordner des Android SDK zeigt. Mein Befehl sieht zum Beispiel so aus:
  • Stellen Sie sicher, dass ADB (Android Debug Bridge) sowohl den Emulator als auch Ihr angeschlossenes Smartphone oder Tablet erkennt, indem Sie den Befehl /.adb devices ausführen. Es sollte die Codes für zwei separate Geräte zurückgeben.
  • Leiten Sie den Kommunikationsport Ihres AVD an das angeschlossene Smartphone oder Tablet weiter, indem Sie den folgenden Befehl im Terminal-/Eingabeaufforderungsfenster ausführen:
  • Starten Sie auf Ihrem Handheld die Wear OS-App. Navigieren Sie durch alle einführenden Dialoge, bis Sie den Hauptbildschirm von Wear OS erreichen.
  • Öffnen Sie das Dropdown-Menü in der oberen linken Ecke und wählen Sie Neue Uhr hinzufügen aus.
  • Tippen Sie auf das gepunktete Symbol in der oberen rechten Ecke und wählen Sie Mit Emulator koppeln. Nach wenigen Augenblicken sollte sich das Handheld mit Ihrem Emulator verbinden.
Use the Wear OS app to pair your emulator with your Android smartphone or tabletUse the Wear OS app to pair your emulator with your Android smartphone or tabletUse the Wear OS app to pair your emulator with your Android smartphone or tablet

Jetzt können Sie Ihre App testen! Starten Sie die Wear-Komponente auf Ihrem Emulator und die mobile Komponente auf Ihrem Handheld und experimentieren Sie, indem Sie auf die verschiedenen Talk...-Schaltflächen tippen.

Wenn Sie auf dem Handheld mit dem Wearable sprechen tippen, sollten die folgenden Meldungen angezeigt werden:

  • Handheld: „Ich habe dem Handheld gerade eine Nachricht gesendet.“
  • Wearable: „Ich habe gerade eine Nachricht vom Handheld erhalten.“
You can now exchange messages over the Data Layer using the MessageClient APIYou can now exchange messages over the Data Layer using the MessageClient APIYou can now exchange messages over the Data Layer using the MessageClient API

Wenn Sie auf dem Wearable auf Mit dem Handheld sprechen tippen, sollten die folgenden Meldungen angezeigt werden:

  • Wearable: "Ich habe dem Handheld gerade eine Nachricht geschickt."
  • Handheld: „Ich habe gerade eine Nachricht vom Wearable erhalten.“

Abschluss

In diesem Artikel haben wir uns angesehen, wie Sie Nachrichten zwischen Ihrem Handheld und Ihrer Wearable-App über die Wearable Data Layer austauschen.

In der Produktion würden Sie diese Technik wahrscheinlich verwenden, um etwas Interessanteres zu tun, als nur die gleichen paar Textzeilen auszutauschen! Wenn Sie beispielsweise eine App entwickelt haben, die Musik auf dem Smartphone des Benutzers abspielt, könnten Sie ihm die Möglichkeit geben, Songs direkt vom Wearable abzuspielen, anzuhalten und zu überspringen, indem Sie diese Anweisungen vom Wearable über die Datenschicht an das Handheld senden.

Weitere Informationen zum Wearable Data Layer, einschließlich der Synchronisierung komplexerer Daten, finden Sie in den offiziellen Android-Dokumenten.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.