App Group: creazione di un contenitore condiviso e configurazione dell’accesso

Cos’è App Group?

App Group è un meccanismo del sistema operativo iOS che fornisce un’area di archiviazione condivisa per più processi dello stesso sviluppatore. Senza di esso, ogni estensione opera nel proprio sandbox e non può leggere i dati scritti da un altro componente. App Group risolve questo isolamento creando una directory sul file system accessibile a tutti i processi con i permessi corretti.

L’identificatore di gruppo inizia con il prefisso group. e viene specificato nel file dei permessi del progetto. In Xcode, questo identificatore viene aggiunto tramite Capabilities — il sistema lo include automaticamente nella firma dell’app. Dopo la configurazione, tutti i membri del gruppo ottengono l’accesso alla directory condivisa in Library/Application Support/ all’interno del contenitore.

Secondo Apple WWDC 2020 Session 10026, App Group copre tre scenari chiave: sincronizzazione delle impostazioni tramite NSUserDefaults, condivisione di file tramite FileManager e Core Data condiviso con un unico archivio. Ogni scenario richiede solo di specificare l’identificatore di gruppo nell’API corrispondente.

Come funziona il contenitore condiviso di App Group

iOS crea il contenitore condiviso al primo avvio di qualsiasi processo con il permesso com.apple.security.application-groups. Fisicamente, il contenitore si trova in una directory di sistema — il suo percorso differisce dal sandbox dell’app principale e delle estensioni, ma tutti i processi autorizzati hanno permessi di lettura e scrittura.

Diritti di accesso e sicurezza

Apple garantisce la sicurezza di App Group attraverso la combinazione di team ID e firma del codice. Un processo non firmato con lo stesso certificato di sviluppatore non può accedere al contenitore del gruppo. Ciò impedisce perdite di dati tra app di diversi sviluppatori.

Identificatore di gruppo

Il formato dell’identificatore è: group.<team-id>.<name>. Ad esempio, group.ABC123DEFG.widget-data. È possibile creare più gruppi su un dispositivo, ciascuno con il proprio insieme di membri. Una singola app può appartenere a più App Group contemporaneamente — questo è utile per separare i dati di diverse estensioni.

// Get the App Group container URL
guard let containerURL = FileManager.default
    .containerURL(forSecurityApplicationGroupIdentifier: "group.com.example.widget")
else { return }

// Create a file in the shared container
let fileURL = containerURL.appendingPathComponent("shared.data")
try "Hello from main app".write(to: fileURL, atomically: true, encoding: .utf8)

FileManager fornisce il metodo containerURL(forSecurityApplicationGroupIdentifier:) che restituisce l’URL della directory condivisa. È importante chiamare questo metodo separatamente in ogni processo — il percorso è fisicamente lo stesso, ma ogni processo lo vede attraverso la propria prospettiva di sicurezza.

Configurazione di App Group in Xcode

L’abilitazione di App Group in Xcode inizia con le Capabilities — l’interruttore App Groups aggiunge il permesso al progetto. Apple Developer Portal richiede anche che l’identificatore dell’app includa questa capacità. Senza di essa, la firma del codice non funzionerà su un dispositivo reale.

Configurazione passo passo

Apriti il progetto in Xcode, seleziona il target dell’app e vai alla scheda Signing & Capabilities. Fai clic su + e scegli App Groups. Crea un nuovo gruppo o selezionane uno esistente. Ripeti gli stessi passaggi per ogni estensione che necessita di accesso al contenitore condiviso. Tutti i partecipanti devono utilizzare lo stesso identificatore di gruppo.

Verifica dei permessi

Dopo aver abilitato le Capabilities, Xcode crea automaticamente un file .entitlements con la chiave com.apple.security.application-groups e un array di identificatori. Assicurati che tutte le estensioni necessarie abbiano questo file con il team ID corretto nell’identificatore di gruppo.

<!-- Example entitlements file -->
<key>com.apple.security.application-groups</key>
<array>
    <string>group.com.example.shared</string>
</array>

Se il tuo progetto ha più estensioni (Today Widget, Share Extension, Notification Service), ciascuna deve avere il proprio file dei permessi con lo stesso gruppo. L’assenza di permessi in qualsiasi target è un motivo comune per cui un’estensione non vede i dati condivisi.

Utilizzo di UserDefaults con App Group

Il modo più semplice per sincronizzare i dati tra un’app e le sue estensioni è UserDefaults con un suite name. Invece del standard UserDefaults.standard, crei un’istanza con l’identificatore App Group e tutti i processi leggono le stesse impostazioni.

Secondo le Apple Human Interface Guidelines, questo meccanismo è adatto per sincronizzare lo stato: tema selezionato, preferiti, flag di onboarding. Tuttavia, non è progettato per grandi volumi di dati o operazioni di scrittura concorrenti — per questo utilizza file o Core Data.

// Write to UserDefaults App Group (main app)
let defaults = UserDefaults(suiteName: "group.com.example.shared")
defaults?.set(true, forKey: "isDarkMode")
defaults?.synchronize()

// Read from UserDefaults App Group (widget extension)
let sharedDefaults = UserDefaults(suiteName: "group.com.example.shared")
let isDark = sharedDefaults?.bool(forKey: "isDarkMode") ?? false

Nota: l’istanza UserDefaults con suiteName viene creata separatamente in ogni processo ma legge dallo stesso file plist nel contenitore condiviso. Il metodo synchronize() garantisce la scrittura immediata su disco — in iOS 13+ può essere omesso poiché il sistema sincronizza i dati periodicamente.

Accesso condiviso a file e Core Data

Per scenari più complessi, App Group fornisce l’accesso a un file system condiviso. Qualsiasi file creato nella directory del contenitore è accessibile a tutti i processi del gruppo. Ciò consente un database Core Data condiviso, una cache di immagini o file temporanei.

Configurazione di Core Data con App Group

Per utilizzare un archivio Core Data condiviso, crea un NSPersistentContainer con l’URL del file .sqlite situato nella directory App Group. Assicurati che un solo processo scriva nel database alla volta — la scrittura concorrente può danneggiare i dati. Un’architettura tipica: l’app principale scrive, le estensioni leggono.

// Setup Core Data with App Group container
lazy var persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "SharedModel")
    guard let appGroupURL = FileManager.default
        .containerURL(forSecurityApplicationGroupIdentifier: "group.com.example.shared")
    else { return container }

    let storeURL = appGroupURL.appendingPathComponent("SharedModel.sqlite")
    container.persistentStoreDescriptions = [NSPersistentStoreDescription(url: storeURL)]
    container.loadPersistentStores { _, error in
        if let error = error { fatalError(error.localizedDescription) }
    }
    return container
}()

Un approccio alternativo è una cache di immagini basata su file. NSCache vive solo in memoria, ma tramite App Group puoi salvare le immagini memorizzate nella cache su disco nella directory condivisa. L’estensione widget può accedere agli stessi file e visualizzare dati aggiornati senza download di rete aggiuntivi.

Quando lavori con file condivisi, tieni presente che il sistema può terminare l’estensione in qualsiasi momento. Utilizza NSFileCoordinator per coordinare l’accesso ed evitare il danneggiamento dei dati quando più processi scrivono simultaneamente.