Application Support : stockage des configurations et Core Data

Qu'est-ce qu'Application Support dans iOS ?

Application Support est un répertoire dans le sandbox de l'application iOS conçu pour stocker les données que l'application crée et utilise pour son fonctionnement, mais qui ne sont pas des documents utilisateur. C'est l'emplacement principal pour les configurations, les bases de données, les métadonnées mises en cache et autres fichiers auxiliaires.

iOS désigne Application Support comme une couche intermédiaire entre Documents (données utilisateur) et Caches (données temporaires). Les fichiers dans Application Support peuvent être relativement permanents, mais l'utilisateur ne doit pas y avoir un accès direct — cela le distingue du répertoire Documents.

Selon la Documentation Développeur Apple (2024), Application Support est l'emplacement recommandé pour stocker les bases de données SQLite de Core Data, les fichiers Realm, les configurations au format JSON/plist, les documents de référence téléchargés et autres données que l'application utilise mais que l'utilisateur n'a pas explicitement créées.

Important : par défaut, Application Support est inclus dans la sauvegarde iCloud et iTunes. Si l'application stocke de grandes quantités de données dans ce répertoire qui peuvent être recréées (par exemple, des guides téléchargés), vous devez définir le drapeau isExcludedFromBackup pour les fichiers concernés.

Comment obtenir le chemin d'Application Support

En Swift, le chemin d'accès au répertoire Application Support est obtenu via FileManager.urls(for: .applicationSupportDirectory). Apple recommande de créer un sous-répertoire avec le nom de l'application dans Application Support pour isoler les données.

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 utilise NSSearchPathForDirectoriesInDomains avec NSApplicationSupportDirectory. Comme avec Swift, il est recommandé de créer un sous-répertoire avec le nom de l'application.

@import Foundation;

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

Au premier lancement, le répertoire Application Support peut ne pas exister — il doit être créé en utilisant createDirectory(at:withIntermediateDirectories:). Cela le distingue du répertoire Documents, qui est créé automatiquement par le système.

Quelles données stocker dans Application Support

Application Support convient à une large gamme de données que l'application utilise pour son fonctionnement. Choisir les bonnes données pour ce répertoire améliore l'organisation du système de fichiers et simplifie la sauvegarde.

Bases de données Core Data et Realm

Les fichiers SQLite de Core Data sont créés dans Application Support par défaut. Realm recommande également de placer les bases de données dans ce répertoire. Cela isole les documents utilisateur des bases de données internes de l'application.

Fichiers de configuration

Fichiers JSON, plist, XML avec les paramètres de l'application, Feature Flags, métadonnées utilisateur mises en cache (mais pas les jetons d'authentification — utilisez Keychain pour ceux-ci).

Critère de sélection : si les données sont créées et utilisées par l'application, pas par l'utilisateur, et doivent persister entre les lancements — leur place est dans Application Support.

Core Data et Application Support

Core Data est l'un des principaux consommateurs d'Application Support. Lors de la création d'un NSPersistentContainer, Core Data place automatiquement les fichiers SQLite dans Library/Application Support avec un nom unique basé sur le nom du modèle.

Comprendre où Core Data stocke les fichiers est essentiel pour les migrations, la sauvegarde et le débogage. Principaux fichiers : .sqlite (données), .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]

Lors de l'utilisation de la synchronisation Core Data avec CloudKit, le fichier SQLite reste dans Application Support et CloudKit agit comme une couche de transport. Dans ce cas, il est important de ne pas exclure les fichiers de la sauvegarde — sinon la synchronisation entre les appareils pourrait être interrompue.

Application Support vs Répertoire Documents

La différence entre Application Support et Documents est l'une des plus importantes pour organiser correctement la structure de fichiers de l'application iOS. Un mauvais choix peut amener l'utilisateur à supprimer accidentellement des données importantes de l'application ou, inversement, à ne pas pouvoir trouver ses fichiers.

Règle simple : si l'utilisateur doit voir le fichier et pouvoir le supprimer — utilisez Documents. Si le fichier est nécessaire au fonctionnement de l'application mais que l'utilisateur n'a pas besoin de le savoir — utilisez Application Support. Si les données peuvent être recréées — utilisez Caches.

Bonnes pratiques pour travailler avec Application Support

Travailler avec Application Support nécessite de prendre en compte plusieurs caractéristiques qui le distinguent des autres répertoires du sandbox. Suivre ces bonnes pratiques permet d'éviter la perte de données, les problèmes de migration et les comportements inattendus de l'application.

Toujours créer le répertoire au premier lancement

Contrairement à Documents, Application Support peut ne pas exister au premier lancement. Utilisez createDirectory(at:withIntermediateDirectories:) avec le paramètre withIntermediateDirectories: true pour garantir la création de toute la chaîne de sous-répertoires.

Utiliser un sous-répertoire avec Bundle Identifier

Créez un sous-répertoire avec le Bundle Identifier dans Application Support. Cela isole les données de votre application des autres applications (bien que le sandbox fournisse déjà l'isolation) et simplifie la migration lors d'un changement de fournisseur.

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
    }
}

Suivre ces bonnes pratiques garantit que les données de service de l'application sont correctement organisées, protégées contre la suppression accidentelle par l'utilisateur et correctement restaurées à partir des sauvegardes.