Travailler avec des fichiers dans Flutter

Travailler avec des fichiers dans Flutter

1. Objectifs

• Installer et Configurer le Plugin path_provider :
• Apprendre à ouvrir un fichier existant et à y ajouter du contenu.
• Apprendre à ouvrir un fichier existant et à y ajouter du contenu.
• Utiliser des techniques pour gérer les données de manière sécurisée et cohérente.

2. Introduction

• Travailler avec des fichiers dans Flutter implique la gestion de la lecture et de l’écriture de fichiers sur le système de fichiers local de l’appareil.
• Flutter fournit plusieurs packages pour faciliter cette tâche, notamment path_provider et dart:io. Voici une vue d’ensemble des concepts importants et un exemple pratique.
• Packages Nécessaires :
• path_provider : Utilisé pour trouver des emplacements sur le système de fichiers, tels que le répertoire d’application ou le répertoire temporaire.
• dart:io : Fournit des classes pour travailler avec les fichiers et les répertoires.
• Emplacements de Fichiers :
• Documents Directory : Pour stocker des fichiers que l’utilisateur peut voir et gérer.
• Temporary Directory : Pour stocker des fichiers temporaires qui peuvent être supprimés par le système.
• Opérations de Fichiers :
• Lire un fichier : Lire le contenu d’un fichier existant.
• Écrire dans un fichier : Créer ou modifier un fichier avec des donnes.
• Supprimer un fichier : Supprimer un fichier du système.

3. Usage des répertoires communs

1. Temporary Directory

• Description : Ce répertoire est destiné aux fichiers temporaires. Les fichiers stockés ici peuvent être supprimés à tout moment par le système, donc ils ne sont pas fiables pour un stockage à long terme.
• Utilisation : Idéal pour des fichiers temporaires tels que des téléchargements en cours ou des caches.

import 'dart:io';
import 'package:path_provider/path_provider.dart';

Future<void> saveTempFile(String fileName, String content) async {
  final directory = await getTemporaryDirectory();
  final file = File('${directory.path}/$fileName');
  await file.writeAsString(content);
  print('Fichier temporaire sauvegardé : ${file.path}');
}

• 1. Importation des bibliothèques nécessaires
• import 'dart:io';
• Cette ligne importe le package Dart dart:io, qui fournit des classes et des fonctions pour gérer les opérations d’entrée/sortie. Ici, il est utilisé pour manipuler des fichiers (File).
• import 'package:path_provider/path_provider.dart';
• Le package path_provider permet d’accéder aux répertoires spécifiques au système (par exemple, le répertoire temporaire ou le répertoire de documents) dans des applications multiplateformes (Android, iOS, Windows, macOS, etc.).
• 2. Définition de la fonction saveTempFile
• Future<void> saveTempFile(String fileName, String content) async {
• Future<void> : La fonction est asynchrone (async) et retourne un Future qui n’a pas de résultat (void). Cela signifie que l’opération se déroule de manière non bloquante et peut être attendue (await) par le code appelant.
• String fileName : Le nom du fichier à créer.
• String content : Le contenu textuel à écrire dans le fichier.
• 3. Récupération du répertoire temporaire
• final directory = await getTemporaryDirectory();
• getTemporaryDirectory() : Une fonction asynchrone fournie par path_provider qui renvoie le chemin du répertoire temporaire du système.
• Sur Android : /data/user/0//cache
• Sur iOS : /Library/Caches
• Sur Windows/macOS/Linux : Le répertoire temporaire standard du système.
• Le résultat est stocké dans la variable directory.
• 4. Création de l’objet File
• final file = File('${directory.path}/$fileName');
• File('${directory.path}/$fileName') : Création d’une instance de la classe File représentant un fichier situé dans le répertoire temporaire avec le nom fourni dans fileName.
• ${directory.path} : Accède au chemin du répertoire temporaire.
• /$fileName : Ajoute le nom du fichier à ce chemin.
• 5. Écriture dans le fichier
• await file.writeAsString(content);
• file.writeAsString(content) : Écrit la chaîne de caractères content dans le fichier.
• await : Attend la fin de l’écriture pour continuer l’exécution.
• 6. Affichage d’un message de confirmation
• print('Fichier temporaire sauvegardé : ${file.path}');
• Affiche dans la console le chemin complet où le fichier temporaire a été sauvegardé.

2. Application Support Directory

• Description : Ce répertoire est utilisé pour stocker des fichiers nécessaires au bon fonctionnement de l’application, mais qui ne sont pas exposés à l’utilisateur. Les fichiers ici sont persistants et non accessibles par d’autres applications.
• Utilisation : Idéal pour des configurations de l’application, des bases de données locales, ou des fichiers de ressources.

import 'dart:io';
import 'package:path_provider/path_provider.dart';

Future<void> saveSupportFile(String fileName, String content) async {
  final directory = await getApplicationSupportDirectory();
  final file = File('${directory.path}/$fileName');
  await file.writeAsString(content);
  print('Fichier de support sauvegardé : ${file.path}');
}

3. Application Documents Directory

• Description : Ce répertoire est destiné à stocker des fichiers générés par l’utilisateur ou des documents importants que vous voulez conserver. Les fichiers ici sont accessibles par l’utilisateur et sauvegardés automatiquement (par exemple, dans iCloud sur iOS).
• Utilisation : Idéal pour des sauvegardes de données utilisateur, des images ou des fichiers texte.

import 'dart:io';
import 'package:path_provider/path_provider.dart';

Future<void> saveUserDocument(String fileName, String content) async {
  final directory = await getApplicationDocumentsDirectory();
  final file = File('${directory.path}/$fileName');
  await file.writeAsString(content);
  print('Fichier de document utilisateur sauvegardé : ${file.path}');
}

4. Exemple Complet : Manipulation de Répertoires

• Voici un exemple complet qui montre comment utiliser ces trois répertoires :

import 'dart:io';
import 'package:path_provider/path_provider.dart';

Future<void> manageFiles() async {
  // Temporary Directory
  final tempDir = await getTemporaryDirectory();
  final tempFile = File('${tempDir.path}/temp.txt');
  await tempFile.writeAsString('Contenu temporaire');
  print('Fichier temporaire créé : ${tempFile.path}');

  // Application Support Directory
  final supportDir = await getApplicationSupportDirectory();
  final supportFile = File('${supportDir.path}/support.txt');
  await supportFile.writeAsString('Contenu de support');
  print('Fichier de support créé : ${supportFile.path}');

  // Application Documents Directory
  final docDir = await getApplicationDocumentsDirectory();
  final docFile = File('${docDir.path}/document.txt');
  await docFile.writeAsString('Document utilisateur');
  print('Document créé : ${docFile.path}');
}

void main() {
  manageFiles();
}

4. Créer et écrire dans un fichier

• 1- Importer les bibliothèques nécessaires :
• Importez les bibliothèques Dart pour les fichiers (dart:io) et le package path_provider pour accéder aux répertoires spécifiques.
• 2- Obtenir le chemin du répertoire temporaire :
• Utilisez la méthode getTemporaryDirectory() pour récupérer le chemin du répertoire temporaire.
• 3- Créer une instance de File:
• Créez un objet File en utilisant le chemin du répertoire temporaire avec le nom de fichier souhaité.
• 4- Écrire dans le fichier :
• Utilisez la méthode writeAsString() pour écrire du contenu dans le fichier.
• 5- Optionnel : Lire le contenu :
• Pour vérifier que le fichier a été écrit correctement, utilisez la méthode readAsString().
• Voici un exemple simple pour créer un fichier nommé sample_file.txt dans le répertoire temporaire et y écrire du contenu :

import 'dart:io'; // Pour la gestion des fichiers
import 'package:path_provider/path_provider.dart'; // Pour accéder aux répertoires spécifiques

Future<void> createAndWriteFile() async {
  try {
    // 1. Obtenir le répertoire temporaire
    final Directory tempDir = await getTemporaryDirectory();
    
    // 2. Créer un fichier nommé 'sample_file.txt' dans ce répertoire
    final File file = File('${tempDir.path}/sample_file.txt');
    
    // 3. Écrire du contenu dans le fichier
    await file.writeAsString('Contenu d\'exemple écrit dans le fichier.');

    // 4. Lire le contenu pour confirmation (optionnel)
    final String fileContent = await file.readAsString();
    print('Contenu du fichier : $fileContent');
    
    // Afficher l'emplacement du fichier
    print('Fichier créé à : ${file.path}');
  } catch (e) {
    // Gérer les erreurs
    print('Erreur lors de la création ou de l\'écriture du fichier : $e');
  }
}
void main() {
  createAndWriteFile();
}
Méthodes utilisées
getTemporaryDirectory()

• Fournit le chemin vers le répertoire temporaire de l’application.
• Les fichiers créés ici peuvent être supprimés par le système à tout moment.
• File
• Permet de manipuler des fichiers (créer, lire, écrire, supprimer).
• writeAsString()
• Écrit une chaîne de caractères dans un fichier. Écrase le contenu existant si le fichier existe déjà.
• readAsString()
• Lit le contenu d’un fichier sous forme de chaîne de caractères.
• Résultat attendu
• Un fichier nommé sample_file.txt est créé dans le répertoire temporaire.
• Le contenu Contenu d’exemple écrit dans le fichier. est écrit à l’intérieur.
• Le chemin complet du fichier est affiché dans la console.

5. Supprimer un fichier

• 1- Importer les bibliothèques nécessaires :
• Importez dart:io pour la gestion des fichiers.
• Importez path_provider pour localiser les répertoires spécifiques (comme le répertoire temporaire).
• 2- Obtenir le chemin du répertoire :
• Récupérez le répertoire contenant le fichier, par exemple, le répertoire temporaire avec getTemporaryDirectory().
• 3- Vérifier si le fichier existe :
• Avant de tenter de le supprimer, vérifiez son existence avec file.exists().
• 4- Supprimer le fichier :
• Utilisez la méthode delete() pour supprimer le fichier.
• 5- Gérer les exceptions :
• Enveloppez la suppression dans un bloc try-catch pour éviter des erreurs imprévues.

import 'dart:io'; // Pour la gestion des fichiers
import 'package:path_provider/path_provider.dart'; // Pour accéder aux répertoires spécifiques

Future<void> deleteFile() async {
  try {
    // 1. Obtenir le répertoire temporaire
    final Directory tempDir = await getTemporaryDirectory();
    
    // 2. Créer une référence au fichier à supprimer
    final File file = File('${tempDir.path}/sample_file.txt');
    
    // 3. Vérifier si le fichier existe
    if (await file.exists()) {
      // 4. Supprimer le fichier
      await file.delete();
      print('Fichier supprimé avec succès : ${file.path}');
    } else {
      print('Le fichier n\'existe pas et ne peut pas être supprimé.');
    }
  } catch (e) {
    // Gérer les erreurs
    print('Erreur lors de la suppression du fichier : $e');
  }
}

void main() {
  deleteFile();
}

6. Créer un répertoire

• Disons maintenant que je veux créer un nouveau fichier, mais dans un certain répertoire :

final Directory tempDir = await getTemporaryDirectory();
final Directory newDirectory =
    Directory('${tempDir.path}/sample_directory');

// Always check that the directory exists
if (await newDirectory.exists() == false) {
  await newDirectory.create();
}

final File file = File('${newDirectory.path}/sample_file.txt');
await file.writeAsString('Sample content to write');

7. Supprimer un répertoire

• Faisons maintenant l’inverse et supprimons le répertoire :

final Directory tempDir = await getTemporaryDirectory();
final Directory newDirectory =
    Directory('${tempDir.path}/sample_directory');

await newDirectory.delete(recursive: true);

8. Liste des fichiers

• Parfois, vous devez répertorier tous les fichiers d’un répertoire pour obtenir certaines de ses statistiques :

final Directory directory = await getTemporaryDirectory();
final List files = directory.listSync();

for (final FileSystemEntity file in files) {
  final FileStat fileStat = await file.stat();
  print('Path: ${file.path}');
  print('Type: ${fileStat.type}');
  print('Changed: ${fileStat.changed}');
  print('Modified: ${fileStat.modified}');
  print('Accessed: ${fileStat.accessed}');
  print('Mode: ${fileStat.mode}');
  print('Size: ${fileStat.size}');
}

9. Copier le fichier

• Maintenant, générons un duplicata du fichier d’exemple précédemment créé :
• 1- Importer les bibliothèques nécessaires :
• Importez dart:io pour la gestion des fichiers.
• Importez path_provider pour accéder aux répertoires spécifiques.
• 2- Obtenir le chemin du fichier source :
• Identifiez le répertoire où se trouve le fichier (par exemple, le répertoire temporaire).
• 3- Créer une copie du fichier :
• Utilisez la méthode file.copy() pour créer un duplicata à un nouvel emplacement ou avec un nouveau nom.
• 4- Vérifier le résultat :
• Assurez-vous que la copie a été effectuée correctement en vérifiant son existence.

final Directory tempDir = await getTemporaryDirectory();
final File file = File('${tempDir.path}/sample_file.txt');

final File copy = await file.copy('${tempDir.path}/copy_file.txt');

10. Renommer le fichier

• Ensuite, modifions le nom du fichier que nous venons de copier :

final Directory tempDir = await getTemporaryDirectory();
final File file = File('${tempDir.path}/copy_file.txt');

await file.rename('${tempDir.path}/new_name.txt');

• Gérer de manière synchrone les opérations sur les fichiers
• Jusqu’à présent, j’ai montré comment gérer les fichiers de manière asynchrone, ce qui est la méthode préférée. Cependant, si pour une raison quelconque les futures ne sont pas une option pour vous, les opérations de fichiers synchrones sont également possibles :

final Directory tempDir = await getTemporaryDirectory();
final File file = File('${tempDir.path}/sample_file.txt');

file.writeAsStringSync('New content to add');