Companion App — mi az, társalkalmazások fejlesztése

Mi az a Companion App — wearable alkalmazás?

Companion App — alkalmazás Apple Watch vagy Wear OS viselhető eszközökhöz, amely a fő iOS vagy Android alkalmazással együtt érkezik. A fő cél a funkcionalitás kiterjesztése a csuklóra: gyors információmegtekintés, üzenetekre válaszolás, zene vezérlése, edzések követése. A Companion App automatikusan települ az órára a főalkalmazás telefonra telepítésekor, ha a fejlesztő beépítette a buildbe.

Architektúra a companion alkalmazás két komponensből áll: iOS/Android alkalmazás (fő) és watchOS/Wear OS alkalmazás (társ). A köztük lévő kommunikáció rendszer API-kon keresztül történik: WatchConnectivity az Apple és Wearable Data Layer a Google számára. Az adatok háttérben kerülnek továbbításra Bluetooth-on vagy Wi-Fi-n — a felhasználó nem látja a szinkronizálási folyamatot. Az órán lévő alkalmazásnak lehet saját UI-ja, amely eltér a mobiltól, a kis képernyőhöz igazítva.

A companion alkalmazások típusai a telefontól való függőség mértékében különböznek. Mirroring alkalmazások a telefon adatainak másolatát jelenítik meg, és kapcsolat nélkül nem működnek. Decoupled alkalmazások saját logikával rendelkeznek, gyorsítótárazzák az adatokat, és a telefontól való leváláskor megőrzik a funkcionalitás egy részét. Independent alkalmazások (watchOS 6+ és Wear OS 3+) telefon nélkül telepíthetők, és teljesen önállóan működnek saját hálózati hozzáféréssel.

WatchConnectivity: iPhone és Apple Watch szinkronizálása

WatchConnectivity — Apple keretrendszer kétirányú kommunikációhoz iPhone és Apple Watch között. Négy adatátviteli mechanizmust biztosít: Application Context (utolsó ismert állapot), File Transfer (bármilyen méretű fájlok), User Info (garantált kézbesítésű szótárak) és Interactive Messaging (kétirányú kommunikáció valós időben). A rendszer automatikusan választ Bluetooth vagy Wi-Fi között a távolságtól és a jel minőségétől függően.

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 — a WatchConnectivity egyetlen mechanizmusa garantált valós idejű kézbesítéssel. Az üzenet elküldése és válasz fogadása 200–500 ms alatt történik aktív kapcsolat esetén. Azonnali választ igénylő műveletekhez használatos: edzés indítása, fizetés megerősítése, okosotthon ajtó nyitása. A munkamenetnek mindkét eszközön aktívnak kell lennie — ha az óra zárolva van vagy az alkalmazás a háttérben van, a kézbesítés nem garantált.

File Transfer API nagy adatmennyiségekhez készült — képek, hangfájlok, exportált edzések. A fájlok a háttérben kerülnek továbbításra még akkor is, ha az alkalmazás be van zárva. Korlátozás — legfeljebb 10 egyidejű átvitel a sorban. Application Context — a leggazdaságosabb mechanizmus: csak az utolsó állapotot továbbítja, törölve a korábbi elküldetlen kontextusokat. Ideális beállítások és aktuális állapot szinkronizálásához.

Wearable Data Layer: Android és Wear OS szinkronizálása

Wearable Data Layer — API a Google Play Services-ből adatok szinkronizálásához Android eszköz és Wear OS óra között. Három protokollt biztosít: DataItem (kulcs-érték párok szinkronizálása), MessageClient (egyirányú üzenetek) és ChannelClient (adatfolyam továbbítás). A DataItems automatikusan szinkronizálódnak a Google Cloud-on keresztül — ha a telefon nem elérhető, az adatok kézbesítésre kerülnek a kapcsolat helyreállításakor.

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 // /edzés/szívverés
                    val data = DataMapItem
                        .fromDataItem(event.dataItem)
                        .dataMap
                    val bpm = data.getInt("bpm")
                    updateUI(bpm)
                }
            }
        }
    }
}

MessageClient — egyirányú üzeneteket küld elérési úttal és bájttömbbel. Parancsokhoz használatos: «Edzés indítása», «Zene szüneteltetése». Az üzenet garantáltan kézbesítésre kerül, ha az eszköz csatlakoztatva van. Üzenet fogadásához Wear OS-en implementálja a WearableListenerService-t és regisztrálja a manifestben. A MessageClient nem támogatja az automatikus gyorsítótárazást — ha az óra le van választva, az üzenet elveszik.

ChannelClient — protokoll adatfolyamokhoz: audio, video, érzékelők folyamatos adatfolyama. Kétirányú csatornát nyit bájttömbök továbbításához. Csak Wear OS 2.0+-n támogatott. A ChannelClient hasznos hang továbbításához telefonról órára Bluetooth-hívásokhoz, valamint külső Bluetooth-érzékelőktől (pulzusmérő, bringaszámítógép) érkező adatok telefonon keresztül órára történő továbbításához.

A companion alkalmazás önálló működése az órán

Önálló működés — a companion alkalmazás azon képessége, hogy funkciókat hajtson végre telefonkapcsolat nélkül. Cellular modullal rendelkező watchOS-en az alkalmazás hálózati kéréseket közvetlenül eSIM-en keresztül küld. LTE-vel rendelkező Wear OS-en hasonló funkcionalitás érhető el. Még mobil modul nélkül is az óra gyorsítótárazza a legutóbbi adatokat a telefontól, és leváláskor megjeleníti azokat — a felhasználó az utolsó szinkronizáláskor aktuális információt látja.

Adatok gyorsítótárazása — az önálló működés kulcseleme. Az alkalmazásnak el kell mentenie az utolsó kapott állapotot az óra helyi tárolójába. watchOS-en UserDefaults vagy CoreData használatos, Wear OS-en — Room Database vagy DataStore. A kapcsolat helyreállításakor a gyorsítótár háttér-szinkronizálással frissül. Ha az adatok több mint 24 órával elavultak, az alkalmazás «Frissítse a telefonkapcsolatot» üzenetet jelenít meg.

Wearable UI korlátozott képernyőhöz az óra képernyője 1.5–2 hüvelyk — a companion alkalmazás felületének maximálisan tömörnek kell lennie. Az Apple a NavigationView-t ajánlja egy oszloppal watchOS-en, a Google — kártyalistát Wear OS-en lapozással a navigációhoz. A gombok mérete legalább 44pt legyen a kényelmes érintéshez. Kerülje a szövegbeviteli mezőket — használjon kész válaszokat, diktálást vagy Digital Crown görgőt.

Energiatakarékos kialakítás — a companion alkalmazás ne merítse le az órát néhány óra alatt. Használjon háttérfrissítéseket minimális időközzel. watchOS-en a WatchConnectivity szünetelteti az adatátvitelt alacsony akkumulátorszintnél, és folytatja töltés után. Wear OS-en a Wearable Data Layer automatikusan kisebb átviteleket egyesít egyetlen átvitelbe az energiamegtakarítás érdekében. Wrist raise — frissítse a UI-t csak akkor, amikor a felhasználó felemeli a csuklóját.

Legjobb gyakorlatok companion alkalmazások fejlesztéséhez

A companion alkalmazás architektúráját a lehetséges kapcsolatvesztés figyelembevételével kell megtervezni. Használja a Repository mintát: egyetlen adatforrás a telefonon szinkronizálódik az óra helyi adattárával. Az órán lévő ViewModel feliratkozik a helyi adattárra, és a kapcsolat állapotától függetlenül jeleníti meg az adatokat. A kapcsolat helyreállításakor az óra Repository-ja WatchConnectivity-n vagy Wearable Data Layer-en keresztül kér adatokat, és frissíti a helyi tárolót.

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

Tesztelés a companion alkalmazás valós órán vagy emulátoron történő ellenőrzést igényel. Az Xcode támogatja az Apple Watch szimulátort az iPhone szimulátorral párban — a WatchConnectivity fizikai eszközök nélkül is tesztelhető. Az Android Studio Wear OS emulátort tartalmaz Wearable Data Layer támogatással. Kritikus tesztesetek: kapcsolat megszakadása átvitel közben, alacsony akkumulátor, két companion alkalmazás egyidejű működése, és telepítés telefon nélkül standalone órára.

A companion alkalmazás publikálása watchOS-en nem igényel külön feltöltést az App Store-ba — az alkalmazás része az iOS binárisnak, és automatikusan felajánlásra kerül telepítésre az órán. Wear OS-en a companion alkalmazás külön kerül publikálásra a Google Play-ben, de ugyanazon a csomagon keresztül kapcsolódik a főalkalmazáshoz. Az iOS App Group és az Android sharedUserId lehetővé teszi a fő- és companion alkalmazás számára közös adattároló használatát.