Application Support: archivio configurazioni e Core Data

Cos'è Application Support in iOS?

Application Support è una directory nel sandbox dell'app iOS progettata per archiviare dati che l'app crea e utilizza per il suo funzionamento, ma che non sono documenti utente. Questo è il luogo principale per configurazioni, database, metadati nella cache e altri file ausiliari.

iOS designa Application Support come un livello intermedio tra Documents (dati utente) e Caches (dati temporanei). I file in Application Support possono essere relativamente permanenti, ma l'utente non dovrebbe avere accesso diretto ad essi — questo lo distingue dalla Directory Documents.

Secondo la Documentazione Sviluppatori Apple (2024), Application Support è il luogo consigliato per archiviare database SQLite di Core Data, file Realm, configurazioni in formato JSON/plist, materiali di riferimento scaricati e altri dati che l'app utilizza ma che l'utente non ha creato esplicitamente.

Importante: di default, Application Support è incluso nel backup di iCloud e iTunes. Se l'app archivia grandi quantità di dati in questa directory che possono essere ricreati (ad esempio, guide scaricate), è necessario impostare il flag isExcludedFromBackup per i file pertinenti.

Come ottenere il percorso di Application Support

In Swift, il percorso della Directory Application Support si ottiene tramite FileManager.urls(for: .applicationSupportDirectory). Apple consiglia di creare una sottodirectory con il nome dell'app all'interno di Application Support per isolare i dati.

import Foundation

let fileManager = FileManager.default
guard let appSupportURL = fileManager.urls(
    for: .applicationSupportDirectory,
    in: .userDomainMask
).first else { return }

// Create app subdirectory
let bundleID = Bundle.main.bundleIdentifier ?? "com.example.app"
let appDir = appSupportURL.appendingPathComponent(bundleID)
try fileManager.createDirectory(
    at: appDir,
    withIntermediateDirectories: true
)

Objective-C utilizza NSSearchPathForDirectoriesInDomains con NSApplicationSupportDirectory. Come per Swift, si consiglia di creare una sottodirectory figlia con il nome dell'app.

@import Foundation;

NSArray *paths = NSSearchPathForDirectoriesInDomains(
    NSApplicationSupportDirectory,
    NSUserDomainMask,
    YES
);
NSString *appSupportPath = paths.firstObject;
NSString *appDir = [appSupportPath stringByAppendingPathComponent:@"com.example.app"];

Al primo avvio, la directory Application Support potrebbe non esistere — deve essere creata utilizzando createDirectory(at:withIntermediateDirectories:). Questo la distingue dalla Directory Documents, che viene creata automaticamente dal sistema.

Quali dati archiviare in Application Support

Application Support è adatto a un'ampia gamma di dati che l'app utilizza per il suo funzionamento. Scegliere i dati giusti per questa directory migliora l'organizzazione del file system e semplifica il backup.

Database Core Data e Realm

I file SQLite di Core Data vengono creati in Application Support di default. Realm consiglia anche di posizionare i database in questa directory. Questo isola i documenti utente dai database interni dell'app.

File di configurazione

File JSON, plist, XML con impostazioni dell'app, Feature Flags, metadati utente nella cache (ma non token di autenticazione — per quelli usa Keychain).

Criterio di selezione: se i dati sono creati e utilizzati dall'app, non dall'utente, e devono persistere tra le esecuzioni — il loro posto è in Application Support.

Core Data e Application Support

Core Data è uno dei principali consumatori di Application Support. Quando si crea un NSPersistentContainer, Core Data posiziona automaticamente i file SQLite in Library/Application Support con un nome univoco basato sul nome del modello.

Capire dove Core Data archivia i file è fondamentale per le migrazioni, il backup e il debug. File principali: .sqlite (dati), .sqlite-wal (Write-Ahead Log), .sqlite-shm (Shared Memory).

import CoreData

// Create Core Data container
let container = NSPersistentContainer(name: "MyAppModel")

// Custom store URL directory
guard let appSupportURL = FileManager.default
    .urls(for: .applicationSupportDirectory,
        in: .userDomainMask).first else { return }

let storeURL = appSupportURL
    .appendingPathComponent("MyAppModel.sqlite")
let description = NSPersistentStoreDescription(url: storeURL)
container.persistentStoreDescriptions = [description]

Quando si utilizza la sincronizzazione Core Data con CloudKit, il file SQLite rimane in Application Support e CloudKit agisce come livello di trasporto. In questo caso, è importante non escludere i file dal backup — altrimenti la sincronizzazione tra dispositivi potrebbe interrompersi.

Application Support vs Directory Documents

La differenza tra Application Support e Documents è una delle più importanti per organizzare correttamente la struttura dei file dell'app iOS. Una scelta errata può portare l'utente a eliminare accidentalmente dati importanti dell'app o, al contrario, a non riuscire a trovare i propri file.

Regola semplice: se l'utente deve vedere il file e poterlo eliminare — usa Documents. Se il file è necessario per il funzionamento dell'app ma l'utente non deve saperlo — usa Application Support. Se i dati possono essere ricreati — usa Caches.

Migliori pratiche per lavorare con Application Support

Lavorare con Application Support richiede di considerare diverse caratteristiche che lo distinguono dalle altre directory del sandbox. Seguire queste pratiche aiuta a evitare perdita di dati, problemi di migrazione e comportamenti imprevisti dell'app.

Creare sempre la directory al primo avvio

A differenza di Documents, Application Support potrebbe non esistere al primo avvio. Usa createDirectory(at:withIntermediateDirectories:) con il parametro withIntermediateDirectories: true per garantire la creazione dell'intera catena di sottodirectory.

Usare una sottodirectory con Bundle Identifier

Crea una sottodirectory con il Bundle Identifier all'interno di Application Support. Questo isola i dati della tua app dalle altre app (sebbene il sandbox fornisca già isolamento) e semplifica la migrazione quando si cambia fornitore.

import Foundation

enum AppSupport {
    static func ensureDirectory() throws -> URL {
        let fm = FileManager.default
        let baseURL = try fm.url(
            for: .applicationSupportDirectory,
            in: .userDomainMask,
            appropriateFor: nil,
            create: true
        )
        let appDir = baseURL
            .appendingPathComponent(Bundle.main.bundleIdentifier ?? "default")
        try fm.createDirectory(at: appDir, withIntermediateDirectories: true)
        return appDir
    }
}

Seguire queste pratiche garantisce che i dati di servizio dell'app siano organizzati correttamente, protetti da eliminazione accidentale da parte dell'utente e ripristinati correttamente dai backup.