Companion App — wat is het, ontwikkeling van companion-apps

Wat is Companion App — app voor wearable?

Companion App — app voor draagbare apparaten Apple Watch of Wear OS, die samen met de hoofd-iOS- of Android-app wordt geleverd. Het hoofddoel is het uitbreiden van functionaliteit naar de pols: snel informatie bekijken, berichten beantwoorden, muziek bedienen, trainingen volgen. Companion App wordt automatisch op de watch geïnstalleerd bij installatie van de hoofdapp op de telefoon, als de ontwikkelaar het in de build heeft opgenomen.

Architectuur van de companion-app bestaat uit twee componenten: de iOS/Android-app (hoofd) en de watchOS/Wear OS-app (companion). Communicatie tussen hen verloopt via systeem-API's: WatchConnectivity voor Apple en Wearable Data Layer voor Google. Gegevens worden op de achtergrond verzonden via Bluetooth of Wi-Fi — de gebruiker ziet het synchronisatieproces niet. De app op de watch kan een eigen UI hebben, anders dan mobiel, aangepast aan het kleine scherm.

Soorten companion-apps verschillen in mate van afhankelijkheid van de telefoon. Mirroring-apps tonen een kopie van gegevens van de telefoon en werken niet zonder verbinding. Decoupled-apps hebben eigen logica, cachen gegevens en behouden een deel van de functionaliteit bij ontkoppeling van de telefoon. Independent-apps (watchOS 6+ en Wear OS 3+) kunnen zonder telefoon worden geïnstalleerd en volledig autonoom werken met eigen netwerktoegang.

WatchConnectivity: synchronisatie van iPhone en Apple Watch

WatchConnectivity — Apple's framework voor bidirectionele communicatie tussen iPhone en Apple Watch. Biedt vier mechanismen voor gegevensoverdracht: Application Context (laatst bekende status), File Transfer (bestanden van elke grootte), User Info (woordenboeken met gegarandeerde levering) en Interactive Messaging (bidirectionele communicatie in realtime). Het systeem kiest automatisch Bluetooth of Wi-Fi, afhankelijk van afstand en signaalkwaliteit.

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 — het enige mechanisme van WatchConnectivity met gegarandeerde levering in realtime. Bericht wordt verzonden en krijgt antwoord binnen 200–500 ms bij actieve verbinding. Gebruikt voor acties die onmiddellijke reactie vereisen: starten van training, betaling bevestigen, deur van slim huis openen. Sessie moet op beide apparaten actief zijn — als de watch is vergrendeld of de app op de achtergrond, is levering niet gegarandeerd.

File Transfer API is bedoeld voor grote hoeveelheden gegevens — afbeeldingen, audiobestanden, geëxporteerde trainingen. Bestanden worden op de achtergrond verzonden, zelfs als de app is gesloten. Beperking — tot 10 gelijktijdige transfers in de wachtrij. Application Context — het meest economische mechanisme: verzendt alleen de laatste status, annuleert eerdere niet-verzonden contexten. Ideaal voor synchronisatie van instellingen en huidige status.

Wearable Data Layer: synchronisatie van Android en Wear OS

Wearable Data Layer — API van Google Play Services voor gegevenssynchronisatie tussen Android-apparaat en Wear OS-watch. Biedt drie protocollen: DataItem (synchronisatie van sleutel-waardeparen), MessageClient (unidirectionele berichten) en ChannelClient (streaming gegevensoverdracht). DataItems worden automatisch gesynchroniseerd via Google Cloud — als telefoon niet beschikbaar is, worden gegevens geleverd bij herstel van verbinding.

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/hartslag
                    val data = DataMapItem
                        .fromDataItem(event.dataItem)
                        .dataMap
                    val bpm = data.getInt("bpm")
                    updateUI(bpm)
                }
            }
        }
    }
}

MessageClient — verzendt unidirectionele berichten met een pad en byte-array. Gebruikt voor opdrachten: «Start training», «Pauzeer muziek». Bericht wordt gegarandeerd geleverd als apparaat is verbonden. Voor ontvangst van berichten op Wear OS implementeert u WearableListenerService en registreert u deze in het manifest. MessageClient ondersteunt geen automatische caching — als de watch is losgekoppeld, gaat het bericht verloren.

ChannelClient — protocol voor streaming gegevens: audio, video, continue stroom van sensoren. Opent een bidirectioneel kanaal voor het verzenden van byte-arrays. Alleen ondersteund op Wear OS 2.0+. ChannelClient is nuttig voor het verzenden van audio van telefoon naar watch voor oproepen via Bluetooth en voor het doorgeven van gegevens van externe Bluetooth-sensoren (hartslagmeter, fietscomputer) via telefoon naar watch.

Autonome werking van companion-app op de watch

Autonome werking — het vermogen van de companion-app om functies uit te voeren zonder verbinding met de telefoon. Op watchOS met Cellular-module verzendt de app netwerkverzoeken rechtstreeks via eSIM. Op Wear OS met LTE is vergelijkbare functionaliteit beschikbaar. Zelfs zonder mobiele module cachet de watch de laatste gegevens van de telefoon en toont deze bij ontkoppeling — de gebruiker ziet actuele informatie op het moment van laatste synchronisatie.

Caching van gegevens — sleutelelement van autonome werking. De app moet de laatste ontvangen status opslaan in de lokale opslag van de watch. Op watchOS wordt UserDefaults of CoreData gebruikt, op Wear OS — Room Database of DataStore. Bij herstel van verbinding wordt de cache bijgewerkt door achtergrondsynchronisatie. Als gegevens meer dan 24 uur oud zijn, toont de app de melding «Ververs de verbinding met de telefoon».

Wearable UI voor beperkt scherm de watch heeft een scherm van 1.5–2 inch — de interface van de companion-app moet zo beknopt mogelijk zijn. Apple beveelt NavigationView met één kolom aan op watchOS, Google — een lijst met kaarten op Wear OS met vegen voor navigatie. Knoppen moeten minstens 44pt groot zijn voor comfortabel aanraken. Vermijd tekstinvoervelden — gebruik kant-en-klare antwoorden, dicteren of het Digital Crown-wieltje.

Energiezuinig ontwerp — de companion-app mag de watch niet binnen enkele uren leegtrekken. Gebruik achtergrondupdates met minimaal interval. Op watchOS onderbreekt WatchConnectivity de overdracht bij lage batterij en hervat deze na opladen. Op Wear OS groepeert Wearable Data Layer automatisch kleine overdrachten in één voor energiebesparing. Wrist raise — werk de UI alleen bij wanneer de gebruiker de pols optilt.

Beste praktijken voor ontwikkeling van companion-apps

Architectuur van de companion-app moet worden ontworpen met het oog op mogelijk verlies van verbinding. Gebruik het Repository-patroon: één gegevensbron op de telefoon synchroniseert met de lokale repository op de watch. ViewModel op de watch abonneert zich op de lokale repository en toont gegevens onafhankelijk van de verbindingsstatus. Bij herstel van verbinding vraagt Repository op de watch gegevens op via WatchConnectivity of Wearable Data Layer en werkt de lokale opslag bij.

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

Testen van de companion-app vereist controle op een echte watch of emulator. Xcode ondersteunt de Apple Watch-simulator samen met de iPhone-simulator — WatchConnectivity kan worden getest zonder fysieke apparaten. Android Studio bevat een Wear OS-emulator met ondersteuning voor Wearable Data Layer. Kritieke testgevallen: verlies van verbinding tijdens overdracht, lage batterij, gelijktijdige werking van twee companion-apps en installatie zonder telefoon op standalone-watch.

Publicatie van companion-app op watchOS vereist geen aparte upload naar de App Store — de app maakt deel uit van de iOS-binary en wordt automatisch aangeboden voor installatie op de watch. Op Wear OS wordt de companion-app apart gepubliceerd in Google Play, maar gekoppeld aan de hoofdapp via hetzelfde pakket. App Group op iOS en sharedUserId op Android stellen de hoofd- en companion-app in staat om gezamenlijke gegevensopslag te gebruiken.