Apps für Android programmieren leicht gemacht!
Google Wear API

Google Wear API

Heute werden wir uns mit der Google Wear API beschäftigen. Diese API ist Grundlegend für die Nutzung der Smartwatch in Verbindung mit der eigenen Android App. Die Google Wear API schafft somit die Grundlage dafür, dass wir zum Beispiel die Messenger API nutzen können.
Kurzgefasst: Ohne die Wear API kann unsere App nicht mit unserer Smartwatch kommunizieren.

Wir werden uns mit der Einrchtung der Google Wear API beschäftigen, so dass wir in noch folgenden Artikeln dann die entsprechende Kommunikation zwischen mobilem Gerät und der Smartwatch aufbauen können.

 

Vorbereitungen:

Wir benötigen, um die Google Wear API nutzen zu können eine Genehmigung von Google.
Hierzu müssen wir von unserem Debugkey und dem Releasekey einen SHA1 Fingerprint generieren. Diesen Fingerprint übergeben wir an Google und anschließend bekommen wir einen API-Key zurück. Diesen API-Key wiederum fügen wir in unsere App ein. Schwupps haben wir die Genehmigung erhalten.

Wie ihr einen API-Key von Google erhalten und den SHA1 Fingerprint erstellen könnt, erfahrt ihr in einem unserer anderen Artikel: >>Google Cloud API-Key erhalten<<

 

Android-Manifest.xml:

Ich gehe davon aus, dass wir mindestens einen API-Key von Google erhalten haben und fortfahren können.

Im Idealfall sollten wir gleich zwei API-Keys besitzen. Einen API-Key für das Debuggen und einen API-Key für das Veröffentlichen.
Die beiden Keys müssen nun in die Android-Manifest.xml Datei von sowohl der Smartwatch App, als auch der Smartphone App eingefügt werden. Die Google Wear API muss ja schließlich wissen, um welche App es sich handelt.

Wir können der Google API nun sagen, um welche App es sich handelt, wenn wir schreiben:

<manifest>

  [...]

  <application>

    [...]

    <meta-data android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version" />

        <!-- API Key zum Veröffentlichen -->
        <!--<meta-data android:name="com.google.android.gms.games.APP_ID"
            android:value="[Hier den API Key zum veröffentlichen einfügen]" />-->

        <!-- API Key zum Debuggen -->
        <meta-data android:name="com.google.android.gms.games.APP_ID"
            android:value="[Hier den API Key zum debuggen einfügen]" />

    [...]

  </application>

  [...]

</manifest>

Wie ihr sehen könnt gehören diese drei Tags in den Tag „<application>“. Da wir zwei API Keys haben, habe ich den Tag für den API Keys zwei mal eingefügt (einmal für den Debugkey, einmal für den Releasekey). Bitte beachtet, dass ich den Tag für den Releasekey auskommentiert habe, es dürfen also nicht beide Keys gleichzeitig dort stehen. Zum Debuggen lasst ihr es so, wie es ist. Zum Veröffentlichen der App wechselt ihr einfach die Kommentierung.

 

Google Play Service API importieren:

Wir haben es jetzt geschafft der Google Wear API zu sagen, um welche App es sich handelt.
Bisher haben wir aber noch keine Google Wear API in unserem Projekt! 😀
Bitte stelle sicher, dass im Standalone Android SDK Manager die SDK „Google Play Services 30“ installiert ist. Die SDK ist unter „Extras“ im SDK Manager zu finden.

Die Google Wear API muss nun importiert werden.
Wir öffnen die Datei „build.gradle (Module: mobile)“ und fügen unter „dependencies“ ein:

dependencies {
    [...]
    compile 'com.google.android.gms:play-services-wearable:9.0.2'
}

Anschließend öffnen wir „build.gradle (Module: wear)“ und fügen unter „dependencies“ ein:

dependencies {
    [...]
    compile 'com.google.android.gms:play-services-wearable:9.0.2'
}

 

Wir führen einen Gradle Sync durch, um die Wear API zu importieren.

Gradle Sync
Gradle Sync

 

Smartphone App:

Kommen wir zum eigentlichen programmieren der Google Wear API.
Diese setzt sich aus dem Aufruf (der Initialisierung) und den Listenern zusammen. Die Listener sind ihrerseits dazu da, die bestimmten Events der gestarteten Google Wear API abzufangen.

Um diese Listener nutzen zu können bedarf es einer Erweiterung unserer Hauptklasse mit „implements GoogleApiClient.ConnectionCallbacks“.
Das sieht in etwa so aus:

public class MainActivity extends Activity implements GoogleApiClient.ConnectionCallbacks{
    [...]
}

Wir erstellen eine globale Variable „mApiClient“:

private GoogleApiClient mApiClient;

In der Funktion „onCreate“ initialisieren wir den Start der Google Wear API:

mApiClient = new GoogleApiClient.Builder( this )
                .addApi( Wearable.API )
                .addConnectionCallbacks( this )
                .build();

if( mApiClient != null && !(mApiClient.isConnected() || mApiClient.isConnecting()))
    mApiClient.connect();

Zu guter letzt fügen wir zu unserer Hauptklasse noch ein paar Funktionen zu, wie Listener oder Ablaufverbesserungen:

// Wird aufgerufen, wenn die Google Wear API erfolgreich gestartet wurde
@Override
public void onConnected(Bundle bundle) {
    
}

// Beendet die Google Wear API, wenn die App beendet wird
@Override
protected void onDestroy() {
    super.onDestroy();
    mApiClient.disconnect();
}

// Wird aufgerufen, wenn die Verbindung zur Google Wear API (zum Google Server) abgebrochen ist
@Override
public void onConnectionSuspended(int i) {

}

// Startet die Google Wear API neu, falls die App neu geöffnet wird
@Override
protected void onResume(){
    super.onResume();
    if( mApiClient != null && !(mApiClient.isConnected() || mApiClient.isConnecting()))
        mApiClient.connect();
}

// Beendet die Google Wear API, wenn die App geschlossen (nicht beendet) wird
@Override
protected void onStop() {
    if (mApiClient != null && mApiClient.isConnected()) 
        mApiClient.disconnect();
    super.onStop();
}

 

Smartwatch App:

Für die Smartwatch App gehen wir gleich vor, deshalb hier noch einmal der gesamte Code:

public class MainActivity  extends Activity implements GoogleApiClient.ConnectionCallbacks {

    private GoogleApiClient mApiClient;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mApiClient = new GoogleApiClient.Builder( this )
                .addApi( Wearable.API )
                .addConnectionCallbacks( this )
                .build();

        if( mApiClient != null && !( mApiClient.isConnected() || mApiClient.isConnecting() ) )
            mApiClient.connect();

    }

    // Wird aufgerufen, wenn die Google Wear API erfolgreich gestartet wurde
    @Override
    public void onConnected(Bundle bundle) {
        
    }

    // Beendet die Google Wear API, wenn die App beendet wird
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mApiClient.disconnect();
    }

    // Wird aufgerufen, wenn die Verbindung zur Google Wear API (zum Google Server) abgebrochen ist
    @Override
    public void onConnectionSuspended(int i) {

    }

    // Startet die Google Wear API neu, falls die App neu geöffnet wird
    @Override
    protected void onResume(){
        super.onResume();
        if( mApiClient != null && !(mApiClient.isConnected() || mApiClient.isConnecting()))
            mApiClient.connect();
    }

    // Beendet die Google Wear API, wenn die App geschlossen (nicht beendet) wird
    @Override
    protected void onStop() {
        if (mApiClient != null && mApiClient.isConnected()) 
            mApiClient.disconnect();
        super.onStop();
    }

}

Es handelt sich bei dieser Anleitung um eine Minimalinstallation. Wer bessere Fehlerabfragen und Ausfallsicherheit haben möchte, der muss nochmal etwas mehr an Fehleranalyse betreiben.

Marvin

Ich bin 23 Jahre jung und studiere zurzeit Wirtschaftsinformatik an der Georg-August-Universität in Göttingen. Ich bin ein Mensch, der sich neben der Programmierung noch für tausend andere Dinge interessiert, die mal mehr und mal weniger verrückt sind. Vor allem aber bin ich Feuer und Flamme mit der Programmierung von eigenen kleinen Apps und Programmen, die mein Leben bereichern.

Kommentar hinzufügen

*Pflichtfeld