Travailler avec le système de fichiers est le fondement de toute application mobile. Chaque plateforme propose son propre modèle d'accès : Sandbox sur iOS isole les applications dans des conteneurs séparés, tandis que Scoped Storage sur Android restreint l'accès direct au stockage partagé. Selon Google Developer Documentation (2026), l'introduction de Scoped Storage avec Android 10 a nécessité une refonte complète de l'architecture de stockage des données. Dans ce guide, nous aborderons FileManager, MediaStore API, Storage Access Framework et DocumentProvider pour les deux plateformes.
Points clés
Le système de fichiers dans les applications mobiles est un ensemble d'API, de règles de sécurité et de contraintes qui définissent comment les données sont stockées et consultées sur les appareils iOS et Android. Contrairement aux systèmes d'exploitation de bureau, les plateformes mobiles isolent chaque application pour protéger les données utilisateur contre la lecture non autorisée par d'autres programmes.
iOS utilise le modèle Sandbox, où chaque application existe dans son propre conteneur avec des permissions strictement limitées. Avant la version 10, Android fournissait un accès complet au stockage externe, mais avec l'introduction de Scoped Storage, l'approche s'est rapprochée d'iOS. La différence clé est qu'iOS isole complètement le système de fichiers, tandis qu'Android offre plusieurs niveaux d'accès : un répertoire privé, MediaStore public et un accès temporaire via SAF.
Les applications mobiles utilisent trois types de stockage de données. Stockage privé — un répertoire accessible uniquement à l'application pour les fichiers internes et le cache. Stockage partagé — fichiers multimédias via MediaStore (Android) ou Files App (iOS). Stockage cloud — iCloud Drive et Google Drive pour la synchronisation entre appareils. Chaque type a ses propres limites de taille, de durée de vie des fichiers et de conditions d'accès.
| Type de stockage | iOS | Android |
|---|---|---|
| Privé | Documents, Library, Caches | getFilesDir(), getCacheDir() |
| Médias partagés | PHPhotoLibrary via sélecteur | MediaStore API (ContentResolver) |
| Documents partagés | Files App via UIDocumentPicker | Storage Access Framework (SAF) |
| Cloud | iCloud Drive (UIDocument) | Google Drive API |
| Cache | Répertoire Caches, nettoyé par le système | getCacheDir(), getExternalCacheDir() |
Sandbox est l'architecture de sécurité d'iOS qui isole chaque application. Une application ne peut lire et écrire qu'à l'intérieur de son propre bac à sable. Pour accéder aux contacts, photos ou fichiers d'autres applications, des sélecteurs système doivent être utilisés : UIImagePickerController ou UIDocumentPickerViewController. L'accès à Files App est configuré via le flag UIFileSharingEnabled dans Info.plist. Le système de fichiers dans le développement mobile sur iOS nécessite de comprendre la structure des répertoires et de choisir le bon emplacement pour chaque type de données.
Le bac à sable iOS se compose de plusieurs répertoires standard. Documents — pour les fichiers utilisateur, inclus dans iCloud Backup. Caches — pour les données temporaires que le système peut supprimer en cas de manque d'espace de stockage. Temporary — pour les fichiers de la session en cours, effacés au redémarrage. Application Support — pour les données internes de l'application cachées à l'utilisateur. Choisir le mauvais répertoire entraîne des problèmes : sauvegarder le cache dans Documents gaspille de l'espace iCloud et viole les directives d'Apple concernant le système de fichiers.
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 = "Содержимое файла"
// Écriture atomique avec chiffrement
try text.write(
to: fileURL,
atomically: true,
encoding: .utf8
)
La classe FileManager fournit un ensemble complet de méthodes pour gérer les fichiers sur iOS. FileManager.default est un singleton thread-safe adapté à la plupart des opérations. Les méthodes telles que fileExists(atPath:), createDirectory(at:withIntermediateDirectories:attributes:), copyItem(at:to:) et removeItem(at:) couvrent les scénarios de base. Les opérations sur les fichiers de plus de 1 Mo doivent être effectuées dans un thread d'arrière-plan via DispatchQueue.global(). Pour le streaming de gros volumes, utilisez FileHandle au lieu de charger l'intégralité du fichier en mémoire.
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)
}
Avec la sortie d'Android 10, Google a introduit Scoped Storage — un modèle d'accès restreint au système de fichiers. Une application ne peut lire et écrire librement que dans ses répertoires privés. Pour les fichiers multimédias (photos, vidéos, audio), l'API MediaStore est utilisée via ContentResolver. Pour les documents arbitraires, Storage Access Framework est utilisé via Intent ACTION_OPEN_DOCUMENT. Sur Android 11+, l'accès direct à la racine du stockage externe est complètement interdit, et tous les développeurs doivent utiliser les nouvelles API.
MediaStore est un ContentProvider système pour accéder aux fichiers multimédias sur l'appareil. Via ContentResolver, l'application demande l'Uri des fichiers au lieu de chemins directs. MediaStore.Files — pour tous les types de fichiers, Images — pour les images, Video — pour les vidéos, Audio — pour les enregistrements audio. L'écriture dans les répertoires partagés se fait via insert() avec DISPLAY_NAME, MIME_TYPE et RELATIVE_PATH. Après l'insertion, l'application reçoit une Uri à travers laquelle les octets sont écrits. Les types MIME jouent un rôle clé — un type incorrect provoquera une erreur lors de l'ouverture du fichier.
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)
}
}
SAF fournit une interface unifiée pour sélectionner et créer des fichiers sans permissions d'exécution. Intent ACTION_OPEN_DOCUMENT ouvre le gestionnaire de fichiers système sur Android. Après la sélection, l'application reçoit une Uri content:// avec un accès temporaire via FLAG_GRANT_READ_URI_PERMISSION. ACTION_CREATE_DOCUMENT permet d'enregistrer des fichiers à n'importe quel emplacement de stockage externe choisi par l'utilisateur. SAF fonctionne sur Android 5+ et donne accès aux fichiers de fournisseurs cloud connectés via DocumentsProvider.
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)
Les deux plateformes fournissent des mécanismes intégrés permettant aux utilisateurs de sélectionner des fichiers. Les documents dans les applications mobiles sont transmis via des sélecteurs système qui accordent un accès temporaire à un fichier sans permissions permanentes. Sur iOS, c'est UIDocumentPickerViewController ; sur Android, ACTION_OPEN_DOCUMENT. Les documents dans les applications mobiles peuvent être sélectionnés à la fois depuis le stockage local et les services cloud. L'utilisateur spécifie explicitement le fichier et l'application reçoit une Uri ou une URL avec une durée de validité limitée.
UIDocumentPickerViewController ouvre Files App et permet de sélectionner un ou plusieurs documents. Modes : import (copie dans le bac à sable) et ouverture (accès via URL à portée de sécurité). Pour le filtrage des fichiers, un tableau de types UTType est transmis — par exemple, .pdf et .plainText. Après réception de l'URL, l'application doit appeler startAccessingSecurityScopedResource() avant la lecture et stopAccessingSecurityScopedResource() après la fin. Ne pas appeler stopAccessing entraîne des fuites de ressources système. Les documents dans les applications mobiles sur iOS nécessitent la libération obligatoire des permissions temporaires après avoir terminé le travail avec le fichier.
let picker = UIDocumentPickerViewController(
forOpeningContentTypes: [.pdf, .plainText]
)
picker.allowsMultipleSelection = true
picker.delegate = self
present(picker, animated: true)
// Libération de l'accès dans le délégué
func documentPicker(
_ controller: UIDocumentPickerViewController,
didPickDocumentsAt urls: [URL]
) {
guard let url = urls.first else { return }
url.startAccessingSecurityScopedResource()
defer { url.stopAccessingSecurityScopedResource() }
}
FileProvider est une sous-classe de ContentProvider pour partager des fichiers en toute sécurité entre les applications. Il génère des Uri content:// temporaires basées sur des fichiers provenant de répertoires XML spécifiés. Les autres applications obtiennent l'accès via Intent avec FLAG_GRANT_READ_URI_PERMISSION. DocumentProvider, contrairement à FileProvider, publie des fichiers dans SAF et permet à d'autres applications de parcourir le contenu de votre application dans le cadre du système de fichiers. Pour implémenter DocumentsProvider, vous devez redéfinir queryRoots(), queryChildDocuments() et openDocument(), puis l'enregistrer dans AndroidManifest.xml
La synchronisation cloud donne aux utilisateurs un accès aux documents sur tous leurs appareils. Le système de fichiers dans les applications mobiles est enrichi par une couche cloud : UIDocument sur iOS suit automatiquement les modifications et les synchronise via iCloud. Sur Android, des fonctionnalités similaires sont construites via Google Drive API ou DocumentsProvider avec des racines cloud. Comprendre le système de fichiers dans le développement mobile est essentiel pour construire une synchronisation fiable entre appareils.
UIDocument est une classe abstraite pour travailler avec les documents iCloud. Il enregistre automatiquement les modifications, lit les données et notifie le délégué des mises à jour. En cas de conflit d'écriture, NSFileVersion fournit une liste des versions disponibles — le développeur peut choisir la plus récente ou afficher à l'utilisateur des options de résolution de conflit. La configuration d'Ubiquity Container dans les Capacités du projet est obligatoire pour iCloud Drive. NSFileCoordinator et NSFilePresenter empêchent les conditions de course lors d'un accès simultané depuis plusieurs threads ou appareils.
iOS inclut automatiquement le répertoire Documents dans iCloud Backup. Android fonctionne avec Auto Backup for Apps — le système enregistre les données de getFilesDir(), SharedPreferences et des bases de données SQLite dans Google Drive. Le cache et les fichiers externes ne sont pas inclus dans les sauvegardes. Les deux plateformes permettent de configurer des exclusions : sur iOS via NSURLIsExcludedFromBackupKey, sur Android via une configuration XML des règles de sauvegarde. Le chiffrement des fichiers contenant des données personnelles est obligatoire — sur iOS utilisez NSDataWritingFileProtectionComplete, sur Android utilisez EncryptedFile de la bibliothèque security-crypto.
| Paramètre | iOS | Android |
|---|---|---|
| Sauvegarde par défaut | Documents et Library | getFilesDir(), SharedPreferences, BD |
| Exclusion de fichiers | isExcludedFromBackupKey | Règles XML de sauvegarde (fullBackupContent) |
| Chiffrement | NSDataWritingFileProtectionComplete | EncryptedFile (security-crypto) |
| Sync cloud | UIDocument + iCloud | Google Drive API + SAF |
| Restauration auto | iCloud Restore après installation | Auto Backup à la réinstallation |
Questions fréquentes
Sandbox est un environnement isolé pour chaque application sur iOS. L'application ne peut pas accéder aux fichiers d'autres applications sans utiliser des sélecteurs système comme UIDocumentPickerViewController.
Scoped Storage est un modèle d'accès restreint au système de fichiers sur Android 10+. L'application lit directement uniquement ses propres fichiers, utilise MediaStore API pour les médias et Storage Access Framework pour les documents.
Utilisez UIDocumentPickerViewController — le sélecteur système pour choisir des documents depuis Files App ou iCloud Drive. Après la sélection, vous recevez une URL à portée de sécurité avec un accès temporaire.
Pour les fichiers multimédias, utilisez MediaStore API via ContentResolver en spécifiant le type MIME. Pour les documents arbitraires, utilisez Storage Access Framework avec Intent ACTION_OPEN_DOCUMENT.
FileProvider est une sous-classe de ContentProvider pour partager des fichiers en toute sécurité entre applications via une Uri content:// temporaire avec FLAG_GRANT_READ_URI_PERMISSION.
Résumé
Nous développerons une application mobile clé en main
IT Sectr crée des applications iOS et Android pour les startups et les entreprises depuis 2017. Nous vous conseillerons et vous proposerons la meilleure solution.