Companion App — co to jest, tworzenie aplikacji towarzyszących

Czym jest Companion App — aplikacja dla wearable?

Companion App — aplikacja na urządzenia noszone Apple Watch lub Wear OS, dostarczana w parze z główną aplikacją iOS lub Android. Głównym celem jest rozszerzenie funkcjonalności na nadgarstek: szybki podgląd informacji, odpowiedź na wiadomości, sterowanie muzyką, śledzenie treningów. Companion App instaluje się automatycznie na zegarku przy instalacji głównej aplikacji na telefonie, jeśli programista uwzględnił go w buildzie.

Architektura companion aplikacji obejmuje dwa komponenty: aplikację iOS/Android (główna) i aplikację watchOS/Wear OS (towarzysząca). Komunikacja między nimi odbywa się przez systemowe API: WatchConnectivity dla Apple i Wearable Data Layer dla Google. Dane są przesyłane w tle przez Bluetooth lub Wi-Fi — użytkownik nie widzi procesu synchronizacji. Aplikacja na zegarku może mieć własny UI, różny od mobilnego, dostosowany do małego ekranu.

Typy companion aplikacji różnią się stopniem zależności od telefonu. Mirroring- aplikacje wyświetlają kopię danych z telefonu i nie działają bez połączenia. Decoupled- aplikacje mają własną logikę, buforują dane i zachowują część funkcjonalności przy odłączeniu od telefonu. Independent- aplikacje (watchOS 6+ i Wear OS 3+) mogą być instalowane bez telefonu i działać w pełni autonomicznie z własnym dostępem sieciowym.

WatchConnectivity: synchronizacja iPhone i Apple Watch

WatchConnectivity — framework Apple do dwukierunkowej komunikacji między iPhone a Apple Watch. Udostępnia cztery mechanizmy przesyłania danych: Application Context (ostatni znany stan), File Transfer (pliki dowolnego rozmiaru), User Info (słowniki z gwarantowaną dostawą) i Interactive Messaging (dwukierunkowa komunikacja w czasie rzeczywistym). System wybiera Bluetooth lub Wi-Fi automatycznie w zależności od odległości i jakości sygnału.

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 — jedyny mechanizm WatchConnectivity z gwarantowaną dostawą w czasie rzeczywistym. Wiadomość jest wysyłana i otrzymuje odpowiedź w ciągu 200–500 ms przy aktywnym połączeniu. Używany do działań wymagających natychmiastowej odpowiedzi: rozpoczęcie treningu, potwierdzenie płatności, otwarcie drzwi smart home. Sesja musi być aktywna na obu urządzeniach — jeśli zegarek jest zablokowany lub aplikacja w tle, dostawa nie jest gwarantowana.

File Transfer API przeznaczony do dużych ilości danych — obrazów, plików audio, wyeksportowanych treningów. Pliki są przesyłane w tle nawet przy zamkniętej aplikacji. Ograniczenie — do 10 jednoczesnych transferów w kolejce. Application Context — najbardziej ekonomiczny mechanizm: przesyła tylko ostatni stan, anulując poprzednie niewysłane konteksty. Idealny do synchronizacji ustawień i bieżącego statusu.

Wearable Data Layer: synchronizacja Android i Wear OS

Wearable Data Layer — API z Google Play Services do synchronizacji danych między urządzeniem Android a zegarkiem Wear OS. Udostępnia trzy protokoły: DataItem (synchronizacja par klucz-wartość), MessageClient (komunikaty jednokierunkowe) i ChannelClient (przesyłanie strumieniowe danych). DataItems są synchronizowane automatycznie przez Google Cloud — jeśli telefon jest niedostępny, dane są dostarczane po przywróceniu połączenia.

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

MessageClient — wysyła komunikaty jednokierunkowe ze ścieżką i tablicą bajtów. Używany do poleceń: «Rozpocznij trening», «Wstrzymaj muzykę». Wiadomość jest dostarczana gwarantowanie, jeśli urządzenie jest podłączone. Aby odbierać wiadomości na Wear OS, zaimplementuj WearableListenerService i zarejestruj go w manifeście. MessageClient nie obsługuje automatycznego buforowania — jeśli zegarek jest odłączony, wiadomość ginie.

ChannelClient — protokół do danych strumieniowych: audio, wideo, ciągły strumień czujników. Otwiera dwukierunkowy kanał do przesyłania tablic bajtów. Obsługiwany tylko na Wear OS 2.0+. ChannelClient jest przydatny do przesyłania audio z telefonu na zegarek do połączeń przez Bluetooth oraz do retransmisji danych z zewnętrznych czujników Bluetooth (pulsometr, komputer rowerowy) przez telefon na zegarek.

Autonomiczna praca companion aplikacji na zegarku

Praca autonomiczna — zdolność companion aplikacji do działania bez połączenia z telefonem. Na watchOS z modułem Cellular aplikacja wysyła żądania sieciowe bezpośrednio przez eSIM. Na Wear OS z LTE dostępna jest podobna funkcjonalność. Nawet bez modułu komórkowego zegarek buforuje ostatnie dane z telefonu i wyświetla je przy rozłączeniu — użytkownik widzi aktualne na moment ostatniej synchronizacji informacje.

Buforowanie danych — kluczowy element pracy autonomicznej. Aplikacja powinna zapisywać ostatni otrzymany stan w lokalnym magazynie zegarka. Na watchOS używa się UserDefaults lub CoreData, na Wear OS — Room Database lub DataStore. Po przywróceniu połączenia pamięć podręczna jest aktualizowana przez synchronizację w tle. Jeśli dane są nieaktualne dłużej niż 24 godziny, aplikacja wyświetla komunikat «Odśwież połączenie z telefonem».

Wearable UI dla ograniczonego ekranu zegarek ma ekran 1.5–2 cala — interfejs companion aplikacji powinien być maksymalnie zwięzły. Apple zaleca NavigationView z jedną kolumną na watchOS, Google — listę kart na Wear OS z przesunięciem do nawigacji. Przyciski powinny mieć rozmiar co najmniej 44pt dla wygodnego dotyku. Unikaj pól tekstowych — używaj gotowych odpowiedzi, dyktowania lub pokrętła Digital Crown.

Projekt energooszczędny — companion aplikacja nie powinna rozładowywać zegarka w ciągu kilku godzin. Używaj aktualizacji w tle z minimalnym interwałem. Na watchOS WatchConnectivity wstrzymuje transmisję przy niskim poziomie baterii i wznawia po naładowaniu. Na Wear OS Wearable Data Layer automatycznie grupuje małe transmisje w jedną, aby oszczędzać energię. Wrist raise — aktualizuj UI tylko przy podniesieniu nadgarstka przez użytkownika.

Najlepsze praktyki tworzenia companion aplikacji

Architektura companion aplikacji powinna być zaprojektowana z uwzględnieniem możliwej utraty połączenia. Użyj wzorca Repository: pojedyncze źródło danych na telefonie synchronizuje się z lokalnym repozytorium na zegarku. ViewModel na zegarku subskrybuje lokalne repozytorium i wyświetla dane niezależnie od stanu połączenia. Po przywróceniu połączenia Repository na zegarku żąda danych przez WatchConnectivity lub Wearable Data Layer i aktualizuje lokalny magazyn.

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

Testowanie companion aplikacji wymaga sprawdzenia na prawdziwym zegarku lub emulatorze. Xcode obsługuje symulator Apple Watch w parze z symulatorem iPhone — można testować WatchConnectivity bez fizycznych urządzeń. Android Studio zawiera emulator Wear OS z obsługą Wearable Data Layer. Krytyczne przypadki testowe: utrata połączenia podczas transmisji, niski poziom baterii, jednoczesna praca dwóch companion aplikacji i instalacja bez telefonu na zegarku standalone.

Publikacja companion aplikacji na watchOS nie wymaga osobnego przesyłania do App Store — aplikacja wchodzi w skład binarnego pliku iOS i automatycznie proponuje się do instalacji na zegarku. Na Wear OS companion aplikacja publikowana jest osobno w Google Play, ale powiązana z główną aplikacją przez ten sam pakiet. App Group na iOS i sharedUserId na Android pozwalają głównej i companion aplikacji korzystać ze wspólnego magazynu danych.