Application Support: vad är det, lagring av konfigurationer och Core Data

Vad är Application Support i iOS?

Application Support — är en katalog i sandlådan för iOS-applikationen, avsedd för lagring av data som applikationen skapar och använder för sin drift, men som inte är användardokument. Detta är den primära platsen för konfigurationer, databaser, cachade metadata och andra hjälpfiler.

iOS särskiljer Application Support som en mellanliggande nivå mellan Documents (användardata) och Caches (temporära data). Filer i Application Support kan vara relativt permanenta, men användaren bör inte ha direkt åtkomst till dem — detta skiljer den från Documents Directory.

Enligt Apple Developer Documentation (2024) är Application Support den rekommenderade platsen för lagring av Core Data SQLite-databaser, Realm-filer, konfigurationer i JSON/plist-format, nedladdade referensmaterial och andra data som applikationen använder men som användaren inte explicit har skapat.

Viktigt: som standard är Application Support inkluderad i iCloud- och iTunes-säkerhetskopiering. Om applikationen lagrar stora volymer data som kan återställas i denna katalog (t.ex. nedladdade guider), måste flaggan isExcludedFromBackup ställas in för motsvarande filer.

Hur man får sökvägen till Application Support

I Swift erhålls sökvägen till Application Support Directory via FileManager.urls(for: .applicationSupportDirectory). Apple rekommenderar att skapa en underkatalog med applikationens namn inuti Application Support för dataisolering.

import Foundation

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

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

Objective-C använder NSSearchPathForDirectoriesInDomains med NSApplicationSupportDirectory. Precis som i Swift rekommenderas att skapa en underkatalog med applikationens namn.

@import Foundation;

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

Vid första start kanske Application Support-katalogen inte finns — den måste skapas med createDirectory(at:withIntermediateDirectories:). Detta skiljer den från Documents Directory som skapas automatiskt av systemet.

Vilka data ska lagras i Application Support

Application Support är lämplig för ett brett spektrum av data som applikationen använder för sin drift. Rätt dataval för denna katalog förbättrar filsystemets organisation och förenklar säkerhetskopiering.

Core Data och Realm databaser

SQLite-filer för Core Data skapas som standard i Application Support. Realm rekommenderar också att placera databaser i denna katalog. Detta isolerar användardokument från applikationens interna databaser.

Konfigurationsfiler

JSON, plist, XML-filer med applikationsinställningar, Feature Flags, cachade metadata om användaren (men inte autentiseringstoken — för dem är Keychain).

Urvalskriterium: om data skapas och används av applikationen, inte av användaren, och ska bevaras mellan starter — deras plats är i Application Support.

Core Data och Application Support

Core Data — en av de främsta förbrukarna av Application Support. Vid skapande av NSPersistentContainer placerar Core Data automatiskt SQLite-filer i Library/Application Support med ett unikt namn baserat på modellnamnet.

Att förstå var Core Data lagrar filer är avgörande för migrationer, säkerhetskopiering och felsökning. Huvudfiler: .sqlite (data), .sqlite-wal (Write-Ahead Log), .sqlite-shm (Shared Memory).

import CoreData

// Skapa Core Data-behållare
let container = NSPersistentContainer(name: "MyAppModel")

// Anpassad butiks-URL-katalog
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]

Vid användning av CloudKit-synkronisering för Core Data förblir SQLite-filen i Application Support och CloudKit används som transportlager. I detta fall är det viktigt att inte exkludera filer från säkerhetskopiering — annars kan synkronisering mellan enheter störas.

Application Support vs Documents Directory

Skillnaden mellan Application Support och Documents — en av de viktigaste för korrekt organisering av filstrukturen för iOS-applikationen. Felaktigt val kan leda till att användaren av misstag raderar viktiga applikationsdata eller, omvänt, inte kan hitta sina egna filer.

Enkel regel: om användaren ska se filen och kunna radera den — använd Documents. Om filen behövs för applikationens drift men användaren inte behöver veta om den — använd Application Support. Om data kan återställas — använd Caches.

Bästa praxis för arbete med Application Support

Arbete med Application Support kräver hänsyn till flera egenskaper som skiljer den från andra kataloger i sandlådan. Att följa dessa metoder hjälper till att undvika dataförlust, migrationsproblem och oväntat applikationsbeteende.

Skapa alltid katalogen vid första start

Till skillnad från Documents kan Application Support saknas vid första start. Använd createDirectory(at:withIntermediateDirectories:) med parametern withIntermediateDirectories: true för att garantera skapandet av hela kedjan av underkataloger.

Använd en underkatalog med Bundle Identifier

Skapa en underkatalog med Bundle Identifier inuti Application Support. Detta isolerar din applikations data från andra applikationers data (även om sandlådan redan ger isolering) och förenklar migration vid leverantörsbyte.

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

Att följa dessa metoder garanterar att applikationens tjänstedata är korrekt organiserade, skyddade från oavsiktlig radering av användaren och korrekt återställda från säkerhetskopior.