Companion App — vad är det, utveckling av följeslagarapplikationer

Vad är Companion App — app för wearable?

Companion App — app för bärbara enheter Apple Watch eller Wear OS, som levereras tillsammans med huvudappen för iOS eller Android. Huvudsyftet är att utöka funktionaliteten till handleden: snabb visning av information, svar på meddelanden, kontroll av musik, spårning av träningspass. Companion App installeras automatiskt på klockan vid installation av huvudappen på telefonen, om utvecklaren har inkluderat den i bygget.

Arkitektur för companion-appen består av två komponenter: iOS/Android-app (huvud) och watchOS/Wear OS-app (följeslagare). Kommunikation mellan dem sker via system-API:er: WatchConnectivity för Apple och Wearable Data Layer för Google. Data överförs i bakgrunden via Bluetooth eller Wi-Fi — användaren ser inte synkroniseringsprocessen. Appen på klockan kan ha ett eget UI, skilt från mobilen, anpassat för den lilla skärmen.

Typer av companion-appar skiljer sig åt i grad av beroende av telefonen. Mirroring-appar visar en kopia av data från telefonen och fungerar inte utan anslutning. Decoupled-appar har egen logik, cache-lagrar data och behåller en del av funktionaliteten vid frånkoppling från telefonen. Independent-appar (watchOS 6+ och Wear OS 3+) kan installeras utan telefon och fungera helt självständigt med egen nätverksåtkomst.

WatchConnectivity: synkronisering av iPhone och Apple Watch

WatchConnectivity — Apples ramverk för tvåvägskommunikation mellan iPhone och Apple Watch. Tillhandahåller fyra mekanismer för dataöverföring: Application Context (senaste kända tillstånd), File Transfer (filer av valfri storlek), User Info (ordböcker med garanterad leverans) och Interactive Messaging (tvåvägskommunikation i realtid). Systemet väljer automatiskt Bluetooth eller Wi-Fi beroende på avstånd och signalstyrka.

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 — den enda mekanismen i WatchConnectivity med garanterad leverans i realtid. Meddelandet skickas och får svar inom 200–500 ms vid aktiv anslutning. Används för åtgärder som kräver omedelbart svar: starta träning, bekräfta betalning, öppna dörren till smart hem. Sessionen måste vara aktiv på båda enheterna — om klockan är låst eller appen i bakgrunden garanteras inte leverans.

File Transfer API är avsett för stora datamängder — bilder, ljudfiler, exporterade träningspass. Filer överförs i bakgrunden även när appen är stängd. Begränsning — upp till 10 samtidiga överföringar i kön. Application Context — den mest ekonomiska mekanismen: överför endast det senaste tillståndet och annullerar tidigare ej skickade kontexter. Idealisk för synkronisering av inställningar och aktuell status.

Wearable Data Layer: synkronisering av Android och Wear OS

Wearable Data Layer — API från Google Play Services för datasynkronisering mellan Android-enhet och Wear OS-klocka. Tillhandahåller tre protokoll: DataItem (synkronisering av nyckel-värdepar), MessageClient (enkelriktade meddelanden) och ChannelClient (strömning av data). DataItems synkroniseras automatiskt via Google Cloud — om telefonen inte är tillgänglig levereras data när anslutningen återställs.

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

MessageClient — skickar enkelriktade meddelanden med sökväg och byte-array. Används för kommandon: «Starta träning», «Pausa musik». Meddelandet levereras garanterat om enheten är ansluten. För att ta emot meddelanden på Wear OS, implementera WearableListenerService och registrera det i manifestet. MessageClient stöder inte automatisk cache-lagring — om klockan är frånkopplad förloras meddelandet.

ChannelClient — protokoll för strömmande data: ljud, video, kontinuerlig ström från sensorer. Öppnar en tvåvägskanal för överföring av byte-arrayer. Stöds endast på Wear OS 2.0+. ChannelClient är användbart för överföring av ljud från telefon till klocka för samtal via Bluetooth och för vidarebefordran av data från externa Bluetooth-sensorer (pulsmätare, cykeldator) via telefon till klocka.

Självständig drift av companion-appen på klockan

Självständig drift — förmågan hos companion-appen att utföra funktioner utan anslutning till telefonen. På watchOS med Cellular-modul skickar appen nätverksförfrågningar direkt via eSIM. På Wear OS med LTE finns liknande funktionalitet. Även utan mobilmodul cache-lagrar klockan de senaste data från telefonen och visar dem vid frånkoppling — användaren ser information som var aktuell vid tidpunkten för senaste synkronisering.

Cache-lagring av data — nyckelelement i självständig drift. Appen bör spara det senaste mottagna tillståndet i klockans lokala lagring. På watchOS används UserDefaults eller CoreData, på Wear OS — Room Database eller DataStore. När anslutningen återställs uppdateras cachen genom bakgrundssynkronisering. Om data är äldre än 24 timmar visar appen meddelandet «Uppdatera anslutningen till telefonen».

Wearable UI för begränsad skärm klockan har en skärm på 1.5–2 tum — companion-appens gränssnitt bör vara så kortfattat som möjligt. Apple rekommenderar NavigationView med en kolumn på watchOS, Google — en lista med kort på Wear OS med svepning för navigering. Knappar bör vara minst 44pt stora för bekväm beröring. Undvik textinmatningsfält — använd färdiga svar, diktat eller Digital Crown-hjulet.

Energieffektiv design — companion-appen bör inte tömma klockans batteri på några timmar. Använd bakgrundsuppdateringar med minimalt intervall. På watchOS pausar WatchConnectivity överföringen vid låg batterinivå och återupptar efter laddning. På Wear OS grupperar Wearable Data Layer automatiskt små överföringar till en för att spara energi. Wrist raise — uppdatera UI endast när användaren lyfter handleden.

Bästa praxis för utveckling av companion-appar

Arkitekturen för companion-appen bör utformas med hänsyn till eventuell förlust av anslutning. Använd Repository-mönstret: en enda datakälla på telefonen synkroniseras med det lokala arkivet på klockan. ViewModel på klockan prenumererar på det lokala arkivet och visar data oberoende av anslutningsstatus. När anslutningen återställs begär Repository på klockan data via WatchConnectivity eller Wearable Data Layer och uppdaterar den lokala lagringen.

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

Testning av companion-appen kräver verifiering på en riktig klocka eller emulator. Xcode stöder Apple Watch-simulatorn tillsammans med iPhone-simulatorn — WatchConnectivity kan testas utan fysiska enheter. Android Studio innehåller en Wear OS-emulator med stöd för Wearable Data Layer. Kritiska testfall: förlust av anslutning under överföring, låg batterinivå, samtidig drift av två companion-appar och installation utan telefon på en standalone-klocka.

Publicering av companion-appen på watchOS kräver ingen separat uppladdning till App Store — appen ingår i iOS-binären och erbjuds automatiskt för installation på klockan. På Wear OS publiceras companion-appen separat i Google Play, men kopplas till huvudappen via samma paket. App Group på iOS och sharedUserId på Android gör det möjligt för huvud- och companion-appen att använda gemensam datalagring.