Companion App — cos'è, sviluppo di applicazioni compagne

Cos'è Companion App — un'applicazione per wearable?

Companion App — un'applicazione per dispositivi indossabili Apple Watch o Wear OS fornita insieme all'app principale iOS o Android. L'obiettivo principale è estendere le funzionalità al polso: visualizzazione rapida delle informazioni, risposta ai messaggi, controllo della musica, monitoraggio degli allenamenti. Companion App viene installata automaticamente sull'orologio quando si installa l'app principale sul telefono, se lo sviluppatore l'ha inclusa nella build.

Architettura di un'app companion comprende due componenti: l'app iOS/Android (principale) e l'app watchOS/Wear OS (compagna). La comunicazione tra di esse avviene tramite API di sistema: WatchConnectivity per Apple e Wearable Data Layer per Google. I dati vengono trasferiti in background via Bluetooth o Wi-Fi — l'utente non vede il processo di sincronizzazione. L'app sull'orologio può avere una propria interfaccia utente, diversa da quella mobile, adattata a un piccolo schermo.

Tipi di app companion si differenziano per il grado di dipendenza dal telefono. Le app specchio mostrano una copia dei dati del telefono e non funzionano senza connessione. Le app disaccoppiate hanno una propria logica, memorizzano i dati nella cache e mantengono parte delle funzionalità quando sono disconnesse dal telefono. Le app indipendenti (watchOS 6+ e Wear OS 3+) possono essere installate senza telefono e funzionare in modo completamente autonomo con proprio accesso alla rete.

WatchConnectivity: sincronizzazione di iPhone e Apple Watch

WatchConnectivity — il framework di Apple per la comunicazione bidirezionale tra iPhone e Apple Watch. Fornisce quattro meccanismi di trasferimento dati: Application Context (ultimo stato noto), File Transfer (file di qualsiasi dimensione), User Info (dizionari con consegna garantita) e Interactive Messaging (comunicazione bidirezionale in tempo reale). Il sistema sceglie automaticamente Bluetooth o Wi-Fi in base alla distanza e alla qualità del segnale.

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 — l'unico meccanismo di WatchConnectivity con consegna garantita in tempo reale. Un messaggio viene inviato e riceve una risposta entro 200–500 ms quando la connessione è attiva. Viene utilizzato per azioni che richiedono una risposta immediata: avviare un allenamento, confermare un pagamento, aprire una porta di casa intelligente. La sessione deve essere attiva su entrambi i dispositivi — se l'orologio è bloccato o l'app è in background, la consegna non è garantita.

File Transfer API è progettato per grandi volumi di dati — immagini, file audio, allenamenti esportati. I file vengono trasferiti in background anche quando l'app è chiusa. Il limite è di 10 trasferimenti simultanei in coda. Application Context è il meccanismo più economico: trasmette solo l'ultimo stato, annullando i contesti precedenti non inviati. È ideale per sincronizzare impostazioni e stato corrente.

Wearable Data Layer: sincronizzazione di Android e Wear OS

Wearable Data Layer — un'API di Google Play Services per sincronizzare i dati tra un dispositivo Android e gli orologi Wear OS. Fornisce tre protocolli: DataItem (sincronizzazione di coppie chiave-valore), MessageClient (messaggi unidirezionali) e ChannelClient (dati in streaming). I DataItem vengono sincronizzati automaticamente tramite Google Cloud — se il telefono non è disponibile, i dati vengono consegnati quando la connessione viene ripristinata.

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 — invia messaggi unidirezionali con un percorso e un array di byte. Viene utilizzato per comandi come "Avvia allenamento" o "Metti in pausa musica". Il messaggio viene consegnato in modo affidabile se il dispositivo è connesso. Per ricevere messaggi su Wear OS, implementare WearableListenerService e registrarlo nel manifest. MessageClient non supporta la cache automatica — se l'orologio è disconnesso, il messaggio viene perso.

ChannelClient — un protocollo per dati in streaming: audio, video, flussi continui di sensori. Apre un canale bidirezionale attraverso il quale vengono trasmessi array di byte. È supportato solo su Wear OS 2.0+. ChannelClient è utile per trasmettere audio dal telefono all'orologio per le chiamate tramite Bluetooth e per ritrasmettere dati da sensori Bluetooth esterni (monitor della frequenza cardiaca, ciclocomputer) attraverso il telefono all'orologio.

Funzionamento autonomo dell'app companion sull'orologio

Funzionamento autonomo — la capacità di un'app companion di funzionare senza connessione al telefono. Su watchOS con modulo Cellular, l'app invia richieste di rete direttamente tramite eSIM. Su Wear OS con LTE, è disponibile una funzionalità simile. Anche senza modulo cellulare, l'orologio memorizza nella cache i dati più recenti dal telefono e li mostra quando è disconnesso — l'utente vede le informazioni aggiornate al momento dell'ultima sincronizzazione.

Memorizzazione nella cache — un elemento chiave del funzionamento autonomo. L'app deve salvare l'ultimo stato ricevuto nella memoria locale dell'orologio. Su watchOS si utilizzano UserDefaults o CoreData, su Wear OS — Room Database o DataStore. Quando la connessione viene ripristinata, la cache viene aggiornata tramite sincronizzazione in background. Se i dati hanno più di 24 ore, l'app mostra un messaggio "Aggiorna la connessione al telefono".

Interfaccia wearable per schermo limitato — l'orologio ha uno schermo di 1,5–2 pollici — l'interfaccia dell'app companion deve essere il più concisa possibile. Apple raccomanda NavigationView a una colonna su watchOS, Google raccomanda un elenco di carte su Wear OS con scorrimento per la navigazione. I pulsanti devono avere almeno 44pt per un tocco confortevole. Evitare campi di inserimento testo — utilizzare risposte predefinite, dettatura o la rotella di scorrimento Digital Crown.

Design efficiente dal punto di vista energetico — l'app companion non deve scaricare la batteria dell'orologio in poche ore. Utilizzare aggiornamenti in background con intervallo minimo. Su watchOS, WatchConnectivity mette in pausa i trasferimenti quando la batteria è bassa e li riprende dopo la ricarica. Su Wear OS, Wearable Data Layer raggruppa automaticamente i piccoli trasferimenti in uno per risparmiare energia. Wrist raise — aggiornare l'interfaccia solo quando l'utente solleva il polso.

Migliori pratiche di sviluppo delle app companion

Architettura dell'app companion dovrebbe essere progettata tenendo conto di una possibile perdita di connessione. Utilizzare il pattern Repository: un'unica fonte di dati sul telefono si sincronizza con il repository locale sull'orologio. Il ViewModel sull'orologio si sottoscrive al repository locale e mostra i dati indipendentemente dallo stato della connessione. Quando la connessione viene ripristinata, il Repository sull'orologio richiede dati tramite WatchConnectivity o Wearable Data Layer e aggiorna l'archiviazione locale.

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

Test di un'app companion richiedono la verifica su orologi reali o un emulatore. Xcode supporta il simulatore Apple Watch abbinato al simulatore iPhone — è possibile testare WatchConnectivity senza dispositivi fisici. Android Studio include un emulatore Wear OS con supporto per Wearable Data Layer. Casi di test critici: perdita di connessione durante il trasferimento, batteria scarica, funzionamento simultaneo di due app companion e installazione senza telefono su orologi autonomi.

Pubblicazione di un'app companion su watchOS non richiede un caricamento separato sull'App Store — l'app è inclusa nel binario dell'app iOS e viene automaticamente offerta per l'installazione sull'orologio. Su Wear OS, l'app companion viene pubblicata separatamente su Google Play ma è collegata all'app principale tramite lo stesso pacchetto. App Group su iOS e sharedUserId su Android consentono all'app principale e all'app companion di utilizzare uno spazio di archiviazione dati condiviso.