Original-URL des Artikels: https://www.golem.de/news/android-wear-sdk-angetestet-erste-programmierversuche-mit-googles-uhr-1404-105606.html    Veröffentlicht: 10.04.2014 09:15    Kurz-URL: https://glm.io/105606

Android-Wear-SDK angetestet

Erste Programmierversuche mit Googles Uhr

Golem.de hat mit der Preview des Android-Wear-SDK herumgespielt. Googles Uhr ist für den Programmierer schnell einzubinden, das stellt aber zugleich den Nutzen in Frage.

Als Google Android Wear vorstellte, veröffentlichte es auch eine Preview auf das SDK. Das kann nicht einfach heruntergeladen werden, sondern erfordert eine Registrierung und eine explizite Freischaltung durch Google. Zumindest bei uns war die Freischaltung aber schon nach kurzer Zeit erfolgreich.



Die Preview besteht eigentlich aus zwei Teilen: dem SDK selbst, das aus einer Jar-Datei besteht, und einem Android-Image, um Google Wear als virtuelles Gerät auf dem Entwicklungsrechner auszuführen. Auf einem realen Android-Handy muss des Weiteren die Android-Wear-App installiert werden. Sie ist derzeit nicht für jeden im Play Store verfügbar, sondern nur für registrierte Preview-Nutzer.



Das Android-Image wird über den Android Virtual Device Manager eingebunden. Es repräsentiert einen Cortex A8 mit 512 MB RAM und stellt zwei verschiedene Displays bereit, beide mit hoher Auflösung - bei Android HDPI genannt: round ist ein rundes Display mit einem Durchmesser von 320 Pixeln, square stellt ein quadratisches Display mit 240 x 240 Pixeln dar.

Die App installieren wir auf einem Nexus 4 mit dem aktuellen Android 4.4.2. Nachdem wir den Entwicklermodus auf dem Gerät aktiviert haben, stecken wir es per USB an unseren Entwicklungsrechner und können loslegen.

Eine App für Android Wear läuft (derzeit) nicht auf der Uhr selbst, sondern auf einem gekoppelten Handy. Auf die etwas ältere Hardware der Uhr oder andere Einschränkungen müssen wir also keine Rücksicht nehmen. Andererseits spielt die Hardware für unsere "Hallo World"-App eigentlich auch keine Rolle. Um die Kommunikation zwischen unserer App und der Uhr kümmert sich die Android-Wear-App.



Was drin ist

So richtig viel bietet die SDK-Preview nicht, es sind gerade mal zwei Funktionen: WearableNotifications und RemoteInput.

Über WearableNotifications sendet eine App einen kleinen - oder großen - Hinweis inklusive Icon an die Uhr. Wem sowohl der Name der Klasse als auch die Funktionsweise selbst bekannt vorkommen, der irrt nicht. Das Verhalten und die Anwendung entsprechen eins zu eins der Notification-Klasse ab Android 4.1. Wer in seiner App bereits Notifications benutzt, dürfte seine App also ohne Probleme Google-Wear-tauglich machen können. Tatsächlich werden mit der Wear-Preview-App auch jetzt schon alle Notifications auf der Uhr dargestellt, was manchmal allerdings recht hässlich aussieht.

Konkrete Unterschiede gibt es aber doch: Die Uhr stellt den kleinen und den großen Hinweis im Wesentlichen gleich dar. Besitzt eine WearableNotification einen kleinen und einen großen Hinweis, wird nur der große dargestellt. Es existiert kein Ausklapp-Mechanismus, bei dem zuerst nur der kleine Hinweis dargestellt wird und erst auf einem zweiten Klick der große - wie in Androids Notification-Center auf einem Handy oder Tablet.

Allerdings bietet WearableNotifications, die Möglichkeit, mehrere Texte ("Pages") in einer Notification zu verketten. Auf der Uhr kann der Nutzer dann über horizontale Wischgesten zwischen den Texten wechseln. Eine Notification wird automatisch um eine Action ergänzt - in Form einer Schaltfläche auf einer eigenen Page. Wenn der Benutzer diese Schaltfläche auslöst, dann ruft die Action einen Intent auf. In unserem Falle ist dieser Intent die einzige Activity (Benutzeroberfläche) in unserer App. Es können aber auch zusätzliche Schaltknöpfe für Actions implementiert werden.

// kleine Notification erzeugen NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(getActivity()) .setSmallIcon(R.drawable.ic_launcher) .setContentTitle(getString(R.string.hallo)) .setContentText(getString(R.string.hallo)) .setContentIntent(viewPendingIntent); // Page für große Notification erzeugen BigTextStyle secondPageStyle = new NotificationCompat.BigTextStyle(); secondPageStyle.setBigContentTitle(getString(R.string.hallo)) .bigText(getString(R.string.hallo_world)); Notification secondPageNotification = new NotificationCompat.Builder(getActivity()) .setStyle(secondPageStyle) .build(); // Spracheingabe für die Benutzer-Interaktion nutzen RemoteInput remoteInput = new RemoteInput.Builder("hello_answer") .setLabel(getString(R.string.answer)) .build(); // Notification zusammenbauen // ohne addRemoteInputForContentIntent würde die // Standard-Action genutzt Notification twoPageNotification = new WearableNotifications.Builder(notificationBuilder) .addPage(secondPageNotification) .addRemoteInputForContentIntent(remoteInput) .build(); NotificationManagerCompat notificationManager = NotificationManagerCompat.from(getActivity()); // Notification abschicken notificationManager.notify(notificationId, twoPageNotification);

Sprich zur Hand

Über RemoteInput ist es möglich, rudimentär über die Uhr mit der eigenen App zu interagieren - abgesehen von der oben genannten Möglichkeit, eigene Schaltflächen zu definieren.

RemoteInput stellt eine Spracheingabe bereit, sie muss explizit für eine Notification aktiviert werden. Wurde eine Spracheingabe erfolgreich verarbeitet, wird die Eingabe dem Intent als Zeichenkette übergeben. Dabei muss der Entwickler aber nicht freien Text interpretieren, sondern kann über eine Ressourcendatei auch bis zu fünf Text-Ansagen vorgeben.

In der aktuellen Preview ist die Spracherkennung noch nicht enthalten, der "gesprochene" Text muss derzeit noch über die Tastatur eingegeben werden.

// Unsere Activity wird nach einer erfolgreichen // Spracheingabe wieder aufgerufen protected void onResume() { /// ... Bundle extras = getIntent().getExtras(); if (extras == null) { return; } // Der Schlüssel entspricht der Definition in // new RemoteInput.Builder("hello_answer") String value = extras.getString("hallo_answer"); if (value != null) { // Text darstellen } }

Fazit

Googles Android-Wear-API ist bislang sehr übersichtlich. Zugriff auf Sensordaten bietet sie bislang nicht. Zum einen, weil es bislang schlicht keine realen Geräte zum Testen gibt. Vermutlich aber auch, weil diese Funktionen bereits durch die bisherige Android-API abgedeckt werden und nur minimal ergänzt werden müssen.

Einfach die bestehende Notification-API zu erweitern, ist praktisch und bereits zum Marktstart werden vermutlich viele Apps Android Wear unterstützen. Dass für eine flexible Interaktion zwischen App und Uhr derzeit nur die Spracheingabe zur Verfügung steht, dürfte sowohl bei so manchem Entwickler als auch bei Nutzern auf Misstrauen und Bedenken stoßen. Andererseits ermöglicht nur sie wirklich kleine, interaktive Geräte - ob die Sprachsteuerung am Arm aber tatsächlich auch in der Praxis taugt, muss die Zukunft zeigen.

Weder in der API noch in der Dokumentation gibt es derzeit Hinweise auf die Möglichkeit, Apps auf der Uhr selbst zu installieren oder zumindest dynamische, grafische Inhalte darzustellen.

Deshalb ist unser Fazit gemischt: Wenn keine wesentlichen neuen Funktionen hinzukommen, wird mit Android Wear nur der ein oder andere Griff zum Handy überflüssig. Für innovative Ideen fehlt es dem Konzept derzeit noch zu sehr an Freiheiten.  (am)


Verwandte Artikel:
Smartwatches: Fehler in Android Wear 2.0 sorgt für Verzögerung   
(31.03.2017, https://glm.io/127068 )
Summit: Montblancs erste Smartwatch ist unspektakulär, aber teuer   
(17.03.2017, https://glm.io/126795 )
Sicherheitslücke: Spectre-Angriff kann Intel SGX überwinden   
(07.03.2018, https://glm.io/133209 )
Android: Google führt API-Level-Grenze im Play Store ein   
(20.12.2017, https://glm.io/131769 )
Android-App für Raspberry programmieren: werGoogelnKann (kann auch Java)   
(23.08.2017, https://glm.io/129559 )

© 1997–2020 Golem.de, https://www.golem.de/