Filsystem och dokument i mobil utveckling: vad det är, vilka principer och hur det fungerar

Författare: IT Sectr Publicerad: 2026-07-19 Lästid: 12 min

Att arbeta med filsystem är grunden för alla mobilapplikationer. Varje plattform erbjuder sin egen åtkomstmodell: Sandbox på iOS isolerar applikationer i separata containrar, medan Scoped Storage på Android begränsar direktåtkomst till delad lagring. Enligt Google Developer Documentation (2026) krävde införandet av Scoped Storage med Android 10 en fullständig översyn av datalagringsarkitekturen. I den här guiden kommer vi att täcka FileManager, MediaStore API, Storage Access Framework och DocumentProvider för båda plattformarna.

Viktiga punkter

  • Sandbox — en isolerad iOS-miljö där varje app endast arbetar i sin egen katalog utan åtkomst till andra appars data.
  • Scoped Storage — Android 10+-modell som begränsar direktåtkomst till extern lagring via MediaStore API och SAF.
  • FileManager — den primära iOS-klassen för filoperationer: skapa, läsa, kopiera, flytta och ta bort.
  • Storage Access Framework — Androids systemmekanism för att välja dokument med Intent ACTION_OPEN_DOCUMENT.
  • DocumentProvider — en Android-komponent för att publicera appfiler i det delade filsystemet via SAF.

Vad är ett filsystem i mobilappar?

Filsystemet i mobilapplikationer är en uppsättning API:er, säkerhetsregler och begränsningar som definierar hur data lagras och nås på iOS- och Android-enheter. Till skillnad från stationära operativsystem isolerar mobila plattformar varje applikation för att skydda användardata från obehörig läsning av andra program.

Arkitektoniska skillnader mellan iOS och Android

iOS använder Sandbox-modellen, där varje app finns i sin egen container med strikt begränsade behörigheter. Före version 10 gav Android full åtkomst till extern lagring, men med införandet av Scoped Storage kom tillvägagångssättet närmare iOS. Huvudskillnaden är att iOS helt isolerar filsystemet, medan Android erbjuder flera åtkomstnivåer: en privat katalog, offentlig MediaStore och tillfällig åtkomst via SAF.

Huvudtyper av lagring

Mobilapplikationer använder tre typer av datalagring. Privat lagring — en katalog som endast är tillgänglig för appen för interna filer och cache. Delad lagring — mediafiler via MediaStore (Android) eller Files App (iOS). Molnlagring — iCloud Drive och Google Drive för synkronisering mellan enheter. Varje typ har sina egna begränsningar gällande storlek, filers livslängd och åtkomstvillkor.

LagringstypiOSAndroid
PrivatDocuments, Library, CachesgetFilesDir(), getCacheDir()
Delad mediaPHPhotoLibrary via väljareMediaStore API (ContentResolver)
Delade dokumentFiles App via UIDocumentPickerStorage Access Framework (SAF)
MolniCloud Drive (UIDocument)Google Drive API
CacheCaches-katalog, rensas av systemetgetCacheDir(), getExternalCacheDir()

Filsystem i mobil utveckling: Sandbox på iOS

Sandbox är iOS säkerhetsarkitektur som isolerar varje applikation. En app kan endast läsa och skriva inuti sin egen sandlåda. För att få åtkomst till kontakter, foton eller filer från andra appar måste systemväljare användas: UIImagePickerController eller UIDocumentPickerViewController. Åtkomst till Files App konfigureras via flaggan UIFileSharingEnabled i Info.plist. Filsystem i mobil utveckling på iOS kräver förståelse för katalogstrukturen och att välja rätt plats för varje datatyp.

Sandlådans katalogstruktur

iOS-sandlådan består av flera standardkataloger. Documents — för användarfiler, ingår i iCloud Backup. Caches — för temporär data som systemet kan ta bort när lagringsutrymmet är lågt. Temporary — för filer i den aktuella sessionen, rensas vid omstart. Application Support — för interna appdata dolda för användaren. Att välja fel katalog leder till problem: att spara cache i Documents slösar med iCloud-utrymme och bryter mot Apples riktlinjer för filsystem.

swift
import Foundation

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

let fileURL = documentsURL.appendingPathComponent("notes.txt")
let text = "Содержимое файла"

// Atomär skrivning med kryptering
try text.write(
    to: fileURL,
    atomically: true,
    encoding: .utf8
)

FileManager — det primära API:et för filoperationer

Klassen FileManager tillhandahåller en komplett uppsättning metoder för att hantera filer på iOS. FileManager.default är en trådsäker singleton som passar för de flesta operationer. Metoder som fileExists(atPath:), createDirectory(at:withIntermediateDirectories:attributes:), copyItem(at:to:) och removeItem(at:) täcker grundläggande scenarier. Filoperationer större än 1 MB bör utföras i en bakgrundstråd via DispatchQueue.global(). För strömning av stora volymer, använd FileHandle istället för att ladda hela filen i minnet.

swift
func readDocumentsFile(named fileName: String) -> String? {
    guard let docsURL = FileManager.default.urls(
        for: .documentDirectory,
        in: .userDomainMask
    ).first else { return nil }

    let fileURL = docsURL.appendingPathComponent(fileName)
    return try? String(contentsOf: fileURL)
}

Filsystem i mobilappar: Scoped Storage på Android

Med lanseringen av Android 10 introducerade Google Scoped Storage — en modell med begränsad åtkomst till filsystemet. En app kan fritt läsa och skriva endast i sina privata kataloger. För mediafiler (foton, videor, ljud) används MediaStore API via ContentResolver. För godtyckliga dokument används Storage Access Framework via Intent ACTION_OPEN_DOCUMENT. På Android 11+ är direkt åtkomst till roten av extern lagring helt förbjuden och alla utvecklare måste använda de nya API:erna.

MediaStore API för att arbeta med mediafiler

MediaStore är en system ContentProvider för åtkomst till mediafiler på enheten. Via ContentResolver begär appen Uri för filer istället för direkta sökvägar. MediaStore.Files — för alla filtyper, Images — för bilder, Video — för videor, Audio — för ljudinspelningar. Skrivning till delade kataloger görs via insert() med DISPLAY_NAME, MIME_TYPE och RELATIVE_PATH. Efter insättning får appen en Uri genom vilken byte skrivs. MIME-typer spelar en avgörande roll — en felaktig typ kommer att orsaka ett fel vid öppning av filen.

kotlin
val contentValues = ContentValues().apply {
    put(MediaStore.MediaColumns.DISPLAY_NAME, "report.pdf")
    put(MediaStore.MediaColumns.MIME_TYPE, "application/pdf")
    put(MediaStore.MediaColumns.RELATIVE_PATH, "Documents/Reports")
}

val uri = contentResolver.insert(
    MediaStore.Files.getContentUri("external"),
    contentValues
)

uri?.let {
    contentResolver.openOutputStream(it)?.use { stream ->
        stream.write(pdfBytes)
    }
}

Storage Access Framework för filval

SAF tillhandahåller ett enhetligt gränssnitt för att välja och skapa filer utan körningsbehörigheter. Intent ACTION_OPEN_DOCUMENT öppnar systemfilhanteraren på Android. Efter val får appen en content:// Uri med tillfällig åtkomst via FLAG_GRANT_READ_URI_PERMISSION. ACTION_CREATE_DOCUMENT gör det möjligt att spara filer på valfri extern lagringsplats som användaren väljer. SAF fungerar på Android 5+ och ger åtkomst till filer från molnleverantörer anslutna via DocumentsProvider.

kotlin
val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
    addCategory(Intent.CATEGORY_OPENABLE)
    type = "*/*"
    putExtra(Intent.EXTRA_MIME_TYPES, arrayOf(
        "application/pdf",
        "text/plain"
    ))
}
startActivityForResult(intent, REQUEST_CODE)

Dokumentval i mobilappar: systemväljare

Båda plattformarna tillhandahåller inbyggda mekanismer för användare att välja filer. Dokument i mobilapplikationer skickas via systemväljare som ger tillfällig åtkomst till en fil utan permanenta behörigheter. På iOS är detta UIDocumentPickerViewController; på Android, ACTION_OPEN_DOCUMENT. Dokument i mobilapplikationer kan väljas från både lokal lagring och molntjänster. Användaren specificerar explicit filen och appen får en Uri eller URL med begränsad giltighetstid.

UIDocumentPickerViewController på iOS

UIDocumentPickerViewController öppnar Files App och gör det möjligt att välja ett eller flera dokument. Lägen: importera (kopiera till sandlådan) och öppna (åtkomst via säkerhetsscopead URL). För filtrering av filer skickas en array av UTType-typer — till exempel .pdf och .plainText. Efter mottagning av URL måste appen anropa startAccessingSecurityScopedResource() före läsning och stopAccessingSecurityScopedResource() efter avslut. Att inte anropa stopAccessing leder till systemresursläckor. Dokument i mobilapplikationer på iOS kräver obligatorisk frigöring av tillfälliga behörigheter efter att arbetet med filen är slutfört.

swift
let picker = UIDocumentPickerViewController(
    forOpeningContentTypes: [.pdf, .plainText]
)
picker.allowsMultipleSelection = true
picker.delegate = self
present(picker, animated: true)

// Frigöra åtkomst i delegaten
func documentPicker(
    _ controller: UIDocumentPickerViewController,
    didPickDocumentsAt urls: [URL]
) {
    guard let url = urls.first else { return }
    url.startAccessingSecurityScopedResource()
    defer { url.stopAccessingSecurityScopedResource() }
}

FileProvider och DocumentProvider på Android

FileProvider är en underklass till ContentProvider för säker delning av filer mellan appar. Den genererar temporära content:// Uri baserade på filer från angivna XML-kataloger. Andra appar får åtkomst via Intent med FLAG_GRANT_READ_URI_PERMISSION. DocumentProvider, till skillnad från FileProvider, publicerar filer i SAF och tillåter andra appar att bläddra i din apps innehåll som en del av filsystemet. För att implementera DocumentsProvider måste du åsidosätta queryRoots(), queryChildDocuments() och openDocument(), och sedan registrera det i AndroidManifest.xml

iCloud Drive och molnfilssynkronisering

Moln synkronisering ger användare åtkomst till dokument på alla sina enheter. Filsystemet i mobilapplikationer förstärks av ett molnlager: UIDocument på iOS spårar automatiskt ändringar och synkroniserar dem via iCloud. På Android byggs liknande funktionalitet via Google Drive API eller DocumentsProvider med molnrötter. Att förstå filsystemet i mobil utveckling är avgörande för att bygga tillförlitlig synkronisering mellan enheter.

UIDocument — Synkronisering på iOS

UIDocument är en abstrakt klass för att arbeta med iCloud-dokument. Den sparar automatiskt ändringar, läser data och meddelar delegerade om uppdateringar. Vid skrivkonflikt tillhandahåller NSFileVersion en lista över tillgängliga versioner — utvecklaren kan välja den senaste eller visa användaren alternativ för konfliktlösning. Konfigurering av Ubiquity Container i projektets Capabilities är obligatorisk för iCloud Drive. NSFileCoordinator och NSFilePresenter förhindrar datakapplöpningar vid samtidig åtkomst från flera trådar eller enheter.

Säkerhetskopiering och återställning av data

iOS inkluderar automatiskt Documents-katalogen i iCloud Backup. Android fungerar med Auto Backup for Apps — systemet sparar data från getFilesDir(), SharedPreferences och SQLite-databaser till Google Drive. Cache och externa filer ingår inte i säkerhetskopior. Båda plattformarna tillåter konfigurering av undantag: på iOS via NSURLIsExcludedFromBackupKey, på Android via XML-konfiguration av säkerhetskopieringsregler. Kryptering av filer med personlig data är obligatorisk — på iOS använd NSDataWritingFileProtectionComplete, på Android använd EncryptedFile från biblioteket security-crypto.

ParameteriOSAndroid
Standard säkerhetskopiaDocuments och LibrarygetFilesDir(), SharedPreferences, DB
FilundantagisExcludedFromBackupKeyXML säkerhetskopieringsregler (fullBackupContent)
KrypteringNSDataWritingFileProtectionCompleteEncryptedFile (security-crypto)
Moln synkUIDocument + iCloudGoogle Drive API + SAF
Auto återställningiCloud Restore efter installationAuto Backup vid ominstallation

Vanliga frågor

Vad är Sandbox på iOS?

Sandbox är en isolerad miljö för varje app på iOS. Appen kan inte komma åt andra appars filer utan att använda systemväljare som UIDocumentPickerViewController.

Vad är Scoped Storage på Android?

Scoped Storage är en modell med begränsad åtkomst till filsystemet på Android 10+. Appen läser direkt endast sina egna filer, använder MediaStore API för media och Storage Access Framework för dokument.

Hur väljer man en fil på iOS?

Använd UIDocumentPickerViewController — systemväljaren för att välja dokument från Files App eller iCloud Drive. Efter val får du en säkerhetsscopead URL med tillfällig åtkomst.

Hur får man åtkomst till filer på Android 11+?

För mediafiler, använd MediaStore API via ContentResolver med angivelse av MIME-typ. För godtyckliga dokument, använd Storage Access Framework med Intent ACTION_OPEN_DOCUMENT.

Vad är FileProvider på Android?

FileProvider är en underklass till ContentProvider för säker delning av filer mellan appar via temporär content:// Uri med FLAG_GRANT_READ_URI_PERMISSION.

Sammanfattning

  • Sandbox — iOS isolerade filsystem där en app endast har åtkomst till sina egna kataloger Documents, Caches och Library.
  • FileManager — det primära API:et för filoperationer på iOS. Läs stora filer via FileHandle i en bakgrundstråd.
  • Scoped Storage — filsystemmodellen på Android 10+ som ersätter direkt åtkomst till extern lagring med MediaStore API och SAF.
  • MediaStore API — en system ContentProvider för att arbeta med mediafiler på Android. Skrivning görs via insert() med ContentValues.
  • Storage Access Framework — en universell dokumentvalsmekanism på Android via ACTION_OPEN_DOCUMENT och ACTION_CREATE_DOCUMENT.
  • UIDocumentPickerViewController — iOS systemväljare som öppnar Files App och iCloud Drive. Fungerar med säkerhetsscopeade URL:er.
  • FileProvider — en mekanism för säker fildelning mellan Android-appar via temporär content:// Uri och körningsbehörigheter.

Vi utvecklar en mobil applikation nyckelfärdigt

IT Sectr skapar iOS- och Android-applikationer för startups och företag sedan 2017. Vi ger dig råd och föreslår den bästa lösningen.

Diskutera projektet