Companion App — was ist das, Entwicklung von Begleitanwendungen

Was ist eine Companion App — eine Anwendung für Wearables?

Companion App — eine Anwendung für tragbare Geräte Apple Watch oder Wear OS, die zusammen mit der Haupt-iOS- oder Android-App geliefert wird. Das Hauptziel ist die Erweiterung der Funktionalität auf das Handgelenk: schnelles Anzeigen von Informationen, Beantworten von Nachrichten, Steuern von Musik, Verfolgen von Trainingseinheiten. Die Companion App wird automatisch auf der Uhr installiert, wenn die Haupt-App auf dem Telefon installiert wird, sofern der Entwickler sie in den Build aufgenommen hat.

Architektur einer Companion-App umfasst zwei Komponenten: die iOS/Android-App (Haupt-App) und die watchOS/Wear OS-App (Begleiter). Die Kommunikation zwischen ihnen erfolgt über System-APIs: WatchConnectivity für Apple und Wearable Data Layer für Google. Daten werden im Hintergrund über Bluetooth oder Wi-Fi übertragen — der Benutzer sieht den Synchronisierungsprozess nicht. Die App auf der Uhr kann eine eigene Benutzeroberfläche haben, die sich von der des Mobilgeräts unterscheidet und an den kleinen Bildschirm angepasst ist.

Arten von Companion-Apps unterscheiden sich im Grad der Abhängigkeit vom Telefon. Mirroring-Apps zeigen eine Kopie der Telefondaten an und funktionieren ohne Verbindung nicht. Decoupled-Apps haben ihre eigene Logik, cachen Daten und behalten beim Trennen vom Telefon einen Teil der Funktionalität. Independent-Apps (watchOS 6+ und Wear OS 3+) können ohne Telefon installiert werden und arbeiten mit eigenem Netzwerkzugriff vollständig autonom.

WatchConnectivity: Synchronisierung von iPhone und Apple Watch

WatchConnectivity — Apples Framework für die bidirektionale Kommunikation zwischen iPhone und Apple Watch. Es bietet vier Datenübertragungsmechanismen: Application Context (letzter bekannter Zustand), File Transfer (Dateien beliebiger Größe), User Info (Wörterbücher mit garantierter Zustellung) und Interactive Messaging (bidirektionale Echtzeitkommunikation). Das System wählt automatisch Bluetooth oder Wi-Fi basierend auf Entfernung und Signalqualität.

import WatchConnectivity

class PhoneSessionManager: NSObject, WCSessionDelegate {
    func activateSession() {
        WCSession.default.delegate = self
        WCSession.default.activate()
    }
    func sendWorkoutData(_ data: WorkoutData) {
        let dict = ["heartRate": data.heartRate,
                     "calories": data.calories] as [String: Any]
        WCSession.default.transferUserInfo(dict)
    }
    func session(_: WCSession,
               didReceiveUserInfo: [String: Any]) {
        DispatchQueue.main.async {
            NotificationCenter.default.post(
                name: .workoutDataReceived,
                object: didReceiveUserInfo)
        }
    }
}

Interactive Messaging — der einzige WatchConnectivity-Mechanismus mit garantierter Echtzeitzustellung. Eine Nachricht wird gesendet und erhält innerhalb von 200–500 ms eine Antwort, wenn die Verbindung aktiv ist. Es wird für Aktionen verwendet, die eine sofortige Antwort erfordern: Starten eines Trainings, Bestätigen einer Zahlung, Öffnen einer Smart-Home-Tür. Die Sitzung muss auf beiden Geräten aktiv sein — wenn die Uhr gesperrt ist oder die App im Hintergrund läuft, ist die Zustellung nicht garantiert.

File Transfer API ist für große Datenmengen ausgelegt — Bilder, Audiodateien, exportierte Trainingseinheiten. Dateien werden auch bei geschlossener App im Hintergrund übertragen. Das Limit beträgt bis zu 10 gleichzeitige Übertragungen in der Warteschlange. Application Context ist der wirtschaftlichste Mechanismus: Er überträgt nur den letzten Zustand und bricht vorherige nicht gesendete Kontexte ab. Ideal zum Synchronisieren von Einstellungen und aktuellem Status.

Wearable Data Layer: Synchronisierung von Android und Wear OS

Wearable Data Layer — eine API von Google Play Services zum Synchronisieren von Daten zwischen einem Android-Gerät und Wear OS-Uhren. Es bietet drei Protokolle: DataItem (Schlüssel-Wert-Paar-Synchronisierung), MessageClient (unidirektionale Nachrichten) und ChannelClient (Streaming-Daten). DataItems werden automatisch über Google Cloud synchronisiert — wenn das Telefon nicht verfügbar ist, werden die Daten bei Wiederherstellung der Verbindung zugestellt.

class WearableSyncService : WearableListenerService() {
    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents.forEach { event ->
            when (event.type) {
                DataEvent.TYPE_CHANGED -> {
                    val uri = event.dataItem.uri
                    val path = uri.path // /workout/heartrate
                    val data = DataMapItem
                        .fromDataItem(event.dataItem)
                        .dataMap
                    val bpm = data.getInt("bpm")
                    updateUI(bpm)
                }
            }
        }
    }
}

MessageClient — sendet unidirektionale Nachrichten mit einem Pfad und Byte-Array. Es wird für Befehle wie "Training starten" oder "Musik pausieren" verwendet. Die Nachricht wird zuverlässig zugestellt, wenn das Gerät verbunden ist. Zum Empfangen von Nachrichten auf Wear OS implementieren Sie WearableListenerService und registrieren es im Manifest. MessageClient unterstützt kein automatisches Caching — wenn die Uhr getrennt ist, geht die Nachricht verloren.

ChannelClient — ein Protokoll für Streaming-Daten: Audio, Video, kontinuierliche Sensorströme. Es öffnet einen bidirektionalen Kanal, über den Byte-Arrays übertragen werden. Es wird nur auf Wear OS 2.0+ unterstützt. ChannelClient ist nützlich zum Übertragen von Audio vom Telefon zur Uhr für Anrufe über Bluetooth und zum Weiterleiten von Daten externer Bluetooth-Sensoren (Herzfrequenzmesser, Fahrradcomputer) über das Telefon an die Uhr.

Autonomer Betrieb der Companion App auf der Uhr

Autonomer Betrieb — die Fähigkeit einer Companion-App, ohne Telefonverbindung zu funktionieren. Auf watchOS mit Cellular-Modul sendet die App Netzwerkanfragen direkt über eSIM. Auf Wear OS mit LTE ist eine ähnliche Funktionalität verfügbar. Auch ohne Mobilfunkmodul cachet die Uhr die neuesten Daten vom Telefon und zeigt sie bei Trennung an — der Benutzer sieht die Informationen, die zum Zeitpunkt der letzten Synchronisierung aktuell waren.

Daten-Caching — ein Schlüsselelement des autonomen Betriebs. Die App muss den letzten empfangenen Zustand im lokalen Speicher der Uhr speichern. Auf watchOS werden UserDefaults oder CoreData verwendet, auf Wear OS — Room Database oder DataStore. Bei Wiederherstellung der Verbindung wird der Cache durch Hintergrundsynchronisierung aktualisiert. Wenn die Daten älter als 24 Stunden sind, zeigt die App eine Meldung "Telefonverbindung aktualisieren" an.

Wearable-Benutzeroberfläche für begrenzte Bildschirme — der Bildschirm der Uhr ist 1,5–2 Zoll groß — die Benutzeroberfläche der Companion-App sollte so prägnant wie möglich sein. Apple empfiehlt NavigationView mit einer Spalte auf watchOS, Google empfiehlt eine Kartenliste auf Wear OS mit Wischen zur Navigation. Schaltflächen sollten mindestens 44pt groß sein, um bequem berührt zu werden. Vermeiden Sie Texteingabefelder — verwenden Sie vordefinierte Antworten, Diktat oder das Digital Crown-Scrollrad.

Energieeffizientes Design — die Companion-App sollte den Akku der Uhr nicht in wenigen Stunden entladen. Verwenden Sie Hintergrundaktualisierungen mit minimalem Intervall. Auf watchOS pausiert WatchConnectivity Übertragungen bei niedrigem Akkustand und setzt sie nach dem Laden fort. Auf Wear OS gruppiert Wearable Data Layer kleine Übertragungen automatisch zu einer, um Energie zu sparen. Handgelenk heben — aktualisieren Sie die Benutzeroberfläche nur, wenn der Benutzer sein Handgelenk hebt.

Bewährte Praktiken für die Entwicklung von Companion-Apps

Architektur der Companion-App sollte unter Berücksichtigung möglicher Verbindungsabbrüche gestaltet werden. Verwenden Sie das Repository-Muster: Eine einzige Datenquelle auf dem Telefon synchronisiert sich mit dem lokalen Repository auf der Uhr. Das ViewModel auf der Uhr abonniert das lokale Repository und zeigt Daten unabhängig vom Verbindungsstatus an. Bei Wiederherstellung der Verbindung fordert das Repository auf der Uhr Daten über WatchConnectivity oder Wearable Data Layer an und aktualisiert den lokalen Speicher.

class WorkoutRepository constructor(
    private val localStorage: WorkoutDao,
    private val wearableClient: WearableClient
) {
    val workoutFlow: Flow<Workout?> = merge(
        localStorage.observeWorkout(),
        wearableClient.observeWorkout()
            .onEach { localStorage.save(it) }
    )
}

Tests einer Companion-App erfordern Überprüfung auf echten Uhren oder einem Emulator. Xcode unterstützt den Apple Watch-Simulator in Verbindung mit dem iPhone-Simulator — Sie können WatchConnectivity ohne physische Geräte testen. Android Studio enthält einen Wear OS-Emulator mit Unterstützung für Wearable Data Layer. Kritische Testfälle: Verbindungsabbruch während der Übertragung, niedriger Akkustand, gleichzeitiger Betrieb von zwei Companion-Apps und Installation ohne Telefon auf eigenständigen Uhren.

Veröffentlichung einer Companion-App auf watchOS erfordert keinen separaten Upload in den App Store — die App ist im iOS-App-Binary enthalten und wird automatisch zur Installation auf der Uhr angeboten. Auf Wear OS wird die Companion-App separat im Google Play veröffentlicht, ist aber über dasselbe Paket mit der Haupt-App verbunden. App Group auf iOS und sharedUserId auf Android ermöglichen der Haupt- und der Companion-App die Nutzung eines gemeinsamen Datenspeichers.