Seite 2: Smarte Uhren

Inhaltsverzeichnis

Smartwatch mit Hirn

Pebble läutete vor etwa drei Jahren die "neue Zeit" der Wearables ein. Die per Kickstarter-Kampagne finanzierte Uhr war schon zum Zeitpunkt der Ankündigung nicht sonderlich modern: Ein mit 80 MHz arbeitender ARM-Prozessor holt keine Katze hinter dem Ofen hervor. Bei der zweiten Generation erwies sich das Unternehmen als ähnlich konservativ: Der E-Paper-Bildschirm zeigt nun zwar bis zu 64 Farben; als MP3-Player oder Kamera taugt das Gadget nach wie vor nicht. Der enorme Erfolg des Geräts liegt allerdings gerade an diesem Mut zur Lücke. Pebbles sind aufgrund der primitiven Hardware leicht; die Akkulaufzeit von bis zu einer Woche sorgt für stressfreie Kurzreisen. Dank des E-Paper-Displays bleibt die Uhrzeit auch dann sichtbar, wenn der Rest der Hardware schlafen gegangen ist.

Softwaretechnisch sieht sich die Pebble – Ähnlichkeiten zu Palm OS sind rein zufällig – als Tentakel zum Zugriff auf die am Smartphone liegenden Daten. Smartwatch-Applikationen lassen sich nur vom Telefon aus installieren, wodurch die Nutzer zum Verbinden von Uhr und Smartphonegezwungen sind. Ein Datenaustauschdienst erlaubt das Senden und Empfangen von Informationen – dank der einfachen API ist die Implementierung auch für weniger erfahrene Entwickler kein Problem.

Pebble OS erinnert an Palms Garnet OS. Die auf C basierende Programmierumgebung arbeitet mit Strukturen, die als eine Art "Pointer" auf die diversen Steuerelemente fungieren. Benutzerschnittstellen bestehen aus einer Gruppe von Ebenen, die übereinandergestapelt werden. In den einzelnen Layern dürfen Entwickler neben den mitgelieferten Steuerelementen selbst gezeichnete Widgets unterbringen.

Das sei nun anhand eines kleinen Beispiels angeschaut, das ein Formular samt Textlabel realisiert. Die einzelnen Steuerelemente werden durch Pointer auf C-Strukturen beschrieben:

#include <pebble.h>
Window *window;
TextLayer *text_layer;

Die eigentliche Initialisierung findet in der Funktion handle_init statt. Beachtet sei, dass der Dialog aus einem Fenster und einem in ihm eingeschriebenen Textlabel (text_layer) besteht. Die beiden Elemente müssen "nacheinander" generiert und ineinander eingeschrieben werden:

void handle_init(void) {
    // Create a window and text layer
    window = window_create();
    text_layer = text_layer_create(GRect(0, 0, 144, 154));

    // Set the text, font, and text alignment
    text_layer_set_text(text_layer, "Hi, I'm a Pebble!");
    text_layer_set_font(text_layer, 
            fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
    text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);

    // Add the text layer to the window
    layer_add_child(window_get_root_layer(window),
                  text_layer_get_layer(text_layer));

    // Push the window
    window_stack_push(window, true);

    // App Logging!
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Just pushed a window!");
}

Pebble OS kommt ohne Garbage Collector aus. handle_deinit ist für das Abtragen der Strukturen verantwortlich:

void handle_deinit(void) {
    // Destroy the text layer
    text_layer_destroy(text_layer);

    // Destroy the window
    window_destroy(window);
}

Zu guter Letzt sei noch ein Blick auf die Hauptmethode geworfen. app_evemt_loop() startet eine Eventloop – die Funktion retourniert erst dann, wenn die Applikation beendet wird:

int main(void) {
    handle_init();
    app_event_loop();
    handle_deinit();
}

Wirklich nützlich wird die Pebble ob der mangelnden Interaktivität – ihre App kann mit dem Nutzer nur über drei Buttons kommunizieren – erst durch eine am Smartphone laufende Companion-Applikation. Diese kommuniziert mit der Uhr durch den Austausch von als Dictionary bezeichneten KV-Speichern.

Aufgrund des eingeschränkten Arbeitsspeichers lassen sich die Inhalte erhaltener Wörterbücher nur nacheinander auslesen. Als Beispiel dafür dient das Snippet, dass das Auslesen eines Schlüssels mit Punktzahlinformationen demonstriert:

static void inbox_received_callback(DictionaryIterator *iterator, 
             void *context) 
{
    Tuple *t = dict_read_first(iterator);
  while(t != NULL) 
  {
    switch (t->key) 
    {
      case 1:
        highScore = (int)t->value->int16;
        break;
    }
    // Get next pair, if any
    t = dict_read_next(iterator);
  }
}

Die am Smartphone befindliche Pebble-Applikation dient beim Entwickeln als Hilfsprogramm zur Datensynchronisation, das die vom SDK erstellten Applikationen auf die Uhr weiterleitet. Neben einer unter Linux lauffähigen nativen Toolchain gibt es mit CloudPebble eine Browser-Entwicklungsumgebung, die einen WYSIWYG-Editor bietet und einen am Server gehosteten Emulator mitbringt.

Tizen auf Abwegen

Bada und Tizen sind aus Samsungs Sicht mit Sicherheit keine besondere Erfolgsgeschichte. Die Wave-Smartphones verkauften sich anfangs gut, wurden jedoch im Laufe der Zeit aufgrund fehlender Wartung immer weniger attraktiv. Das erste Tizen-Smartphone musste mangels Apps die eine oder andere Verschiebung einstecken.

Die Umstellung der Programmierschnittstelle – Samsung setzte anfangs auf den von Bada bekannten OSP-Stack, um später auf das nur wenig verbreitete Enlightenment umzustellen – sorgte zudem dafür, dass Entwickler ihr geistiges Eigentum bis auf die Engine schrotten konnten.

Im Smartwatch-Bereich ist Tizen trotz dieser Ärgernisse ernstzunehmen. Die erste Generation der Gear-Smartwatches erschien mit einem abgespeckten Android, das kurz nach der Ankündigung der Nachfolger durch Tizen ersetzt wurde. Die technisch gut ausgerüsteten Uhren – Samsung verbaut einen OLED-Touchscreen und einen zweikernigen Hauptprozessor – bieten überraschenderweise akzeptable Akkulaufzeiten. Dank des vergleichsweise geringen Einstiegspreises und der diversen Farbvariationen gibt es mittlerweile eine wahre Horde von Uhren am Markt.

Mehr Infos

Was ist ein Watchface?

Auf Smartwatches laufende Programme werden seit dem WristPDA in zwei Kategorien unterteilt. Ein Watchface ist für die Zeitdarstellung zuständig, während eine Watch-App ein Spiel oder eine sonstige Funktion realisiert.

Entwickler dürfen auf ein als Tizen SDK for Wearable bezeichnetes Entwicklerkit zurückgreifen. Damit erzeugte Applikationen werden anhand des Distributionsmodus in drei Gruppen unterteilt. Linked Apps teilen die Uhren- und die Telefonapplikation in separat herunterladbare Teile auf. Bei einer integrierten App kommen Android-App und Tizen-Client als ein APK auf das Telefon des Nutzers; Standalone-Apps sind aufgrund des fehlenden Internetzugriffs nur für Watchfaces und ähnlichen "Kleinkram" geeignet.

Leider schaltet Samsung die unter Tizen verfügbare C++-API derzeit nur für ausgewählte Entwickler frei, die ein NDA unterzeichnen und einen Antrag auf Annahme stellen müssen. Otto Normalentwickler muss im Moment mit JavaScript zurechtkommen. Weitere Informationen zu den diversen Modalitäten findet man in Samsungs Entwicklerportal.

Androide Uhren

Dank der Flexibilität des quelloffenen Betriebssystems war es nur eine Frage der Zeit, bis die erste Smartwatch mit Android-Kern erscheint. Ein mittlerweile aufgelöstes italienisches Start-up namens i'm Watch erzielte mit der gleichnamigen Smartwatch einen Achtungserfolg, konnte sich aber nicht durchsetzen. Das lag an einem konzeptuellen Fehler: Die i'm Watch nutzte ein klassisches LCD als Anzeige. Nutzer mussten eine Taste drücken, um die aktuelle Zeit zu erfahren. Vor drei Jahren sprach man am MWC von 30.000 verkauften Uhren; mittlerweile ist das Start-Up insolvent.

Pearl und Co. setzten dort an, wo die i'm Watch aufhört. Die Versandhändler importieren mehr oder weniger leistungsfähige Smartwatches chinesischer OEMs, die normalerweise mit einem GSM-Modem ausgestattet sind. Auf diese Art und Weise können sie direkt Kontakt mit dem Internet aufnehmen – dass Akkulaufzeit und Bedienbarkeit alles andere als hervorragend sind, folgt aus der Logik. In Deutschland erfreuen sich die Uhren trotzdem einer gewissen Popularität.

Android à la Google

Google erkannte, dass die Komprimierung eines Telefons in eine Armbanduhr aus physikalischen Gründen sinnfrei ist. Android Wear begegnet diesem Problem durch eine neue Benutzerschnittstelle, die auf den Prinzipien "Suggest" und "Demand" basiert. Im Empfehlungsmodus soll die Uhr "Karten" anzeigen, deren Inhalt von der momentanen Lebenssituation des Nutzers beeinflusst wird. Wenn Android Wear angesprochen wird, wechselt die Uhr in den Demand-Betrieb.

Dedizierte Applikationen lassen sich auf Basis der bekannten Android-APIs realisieren. Dabei steht die gesamte API abzüglich der folgenden Namespaces zur Verfügung:

• android.webkit
• android.print
• android.app.backup
• android.appwidget
• android.hardware.usb

Die Interaktion zwischen Uhr und Handy kann auf zwei Arten erfolgen. Am einfachsten ist es, die von der Applikation sowieso ausgegebenen Notifications um zusätzliche Informationen zu erweitern. Die Smartwatch nutzt diese, um die Anzeige der Karten zu optimieren.

Bidirektionale Kommunikation erfolgt per Wearable Data Layer API. Die Programmierschnittstelle bietet Datenstrukturen und Objekte an, die den Datenaustausch zwischen den beiden Geräten erleichtern. Beachtet sei, dass Google vor der Nutzung von Sockets und anderen klassischen Kommunikationskanälen warnt: Wer Daten zwischen Uhr und Handy austauschen will, muss das per WDL-API tun. Die Watchface-API erlaubt das Realisieren alternativer Zifferblättern für die Google Wear: Binäruhren, Swatch Internet Time und ähnliche Spielereien erobern so den Bildschirm von Google Wear.

Als Entwicklungsumgebung ist Android Studio vorgeschrieben: Mit den klassischen ADT (Android Development Tools) arbeitende Entwickler müssen die diversen benötigten Bibliotheken von Hand einbinden. Google realisiert den zur Anzeige kommenden Teil des Watchface überraschenderweise nicht über eine Activity. Stattdessen kommt eine Gruppe von Serviceklassen zum Einsatz, die die Interaktion zwischen Bildschirm und Zeichenlogik über einen geteilten SurfaceHolder bewerkstelligt. Weitere Informationen hierzu finden sich in einem von Google bereitgestellten Tutorial.