La classe path_provider dans Flutter

La classe path_provider dans Flutter

1. Objectifs

• Temporary Directory : Pour les fichiers temporaires qui peuvent être supprimés par le système.
• Application Documents Directory : Pour stocker les fichiers liés aux données utilisateur.
• Application Support Directory : Pour les fichiers nécessaires au bon fonctionnement de l’application.
• External Storage Directory (Android uniquement) : Pour accéder au stockage externe (comme une carte SD).

2. Introduction



• La classe path_provider dans Flutter est une bibliothèque permettant de localiser les chemins système spécifiques à l’application sur le périphérique, comme les répertoires pour les fichiers temporaires, les fichiers permanents ou les fichiers accessibles par l’utilisateur. Elle est très utile pour gérer le stockage des fichiers dans une application Flutter.
• Le package path_provider est un outil puissant de Flutter qui vise à fournir une API pour accéder à différents chemins sur l’appareil d’un utilisateur. Le package fournit des fonctions pour accéder aux chemins d’accès aux fichiers temporaires, aux fichiers permanents et aux chemins de stockage externes. Grâce à ce package, les développeurs peuvent profiter des capacités de stockage local et externe pour stocker et récupérer des fichiers de manière efficace et fiable.

3. Méthodes path_provider

Méthode	Attributs	Décrire
getTemporaryDirectory()	Futur<Directory>	Répertoire temporaire
Exemple : Utilisez cette méthode pour créer ou gérer des fichiers temporaires comme des logs ou des caches qui peuvent être supprimés après utilisation. final tempDir = await getTemporaryDirectory(); File tempFile = File('${tempDir.path}/image_preview.png');
getApplicationSupportDirectory()	Futur<Directory>	Catalogue de support d’applications
Exemple : Stockez des données spécifiques à l’application, telles que des fichiers de configuration ou des bases de données. final supportDir = await getApplicationSupportDirectory(); File configFile = File('${supportDir.path}/config.json');
getLibraryDirectory()	Futur<Directory>	Répertoire de fichiers persistants de l’application
Exemple : Idéal pour des ressources persistantes comme des bibliothèques externes ou des fichiers nécessitant une durée de vie prolongée. final libraryDir = await getLibraryDirectory(); File dbFile = File('${libraryDir.path}/app_database.db');
getApplicationDocumentsDirectory()	Futur<Directory>	Répertoire de documents
Exemple : Utilisez ce répertoire pour enregistrer des fichiers que l’utilisateur pourrait vouloir voir ou gérer, comme des documents ou des images. final docsDir = await getApplicationDocumentsDirectory(); File pdfFile = File('${docsDir.path}/user_guide.pdf');
getExternalStorageDirectory()	Futur<Directory>	Répertoire de stockage externe
Exemple : Enregistrez des fichiers volumineux comme des vidéos ou des fichiers audio qui ne nécessitent pas d’être accessibles depuis l’application directement. final externalDir = await getExternalStorageDirectory(); File videoFile = File('${externalDir.path}/holiday_video.mp4');
getExternalCacheDirectories()	Futur<List<Directory>?>	Répertoire de cache de stockage externe
Exemple : Utilisez pour stocker temporairement des fichiers en cache comme des images ou des réponses d’API. final cacheDirs = await getExternalCacheDirectories(); File cacheFile = File('${cacheDirs.first.path}/response.json');
getExternalStorageDirectories()	Futur<List<Directory>?>	Répertoire de stockage externe (partition séparée)
Exemple : Divisez des fichiers volumineux par partitions pour les applications ayant besoin de différents types de stockage externe. final externalDirs = await getExternalStorageDirectories(); File file = File('${externalDirs.first.path}/backup.zip');
getDownloadsDirectory()	Futur<Directory?>	Répertoire de téléchargement du programme de bureau
Exemple : Téléchargez des fichiers depuis une application vers le répertoire téléchargeable pour une gestion facile par l’utilisateur. final downloadsDir = await getDownloadsDirectory(); File downloadFile = File('${downloadsDir.path}/flutter_setup.exe');

1. getTemporaryDirectory()

• Le répertoire temporaire est utilisé pour stocker des fichiers temporaires qui peuvent être supprimés par le système.
• En Flutter, vous pouvez obtenir le chemin vers ce répertoire en utilisant la méthode getTemporaryDirectory() du plugin path_provider.
• La propriété getTemporaryDirectory() est utilisée pour accéder au chemin où les fichiers temporaires sont stockés sur l’appareil.
• Ce chemin peut être utilisé pour stocker des fichiers qui ne doivent être utilisés que temporairement et qui sont automatiquement supprimés par la suite.
• L’utilisation de getTemporaryDirectory() nécessite d’importer le package path_provider et d’utiliser un objet Directory pour accéder au chemin comme suit :

import 'dart:io'; // Permet d'accéder aux fonctionnalités de manipulation des fichiers et des répertoires.
 // Fournit des méthodes pour obtenir les chemins des répertoires spécifiques.
import 'package:path_provider/path_provider.dart';
//Les opérations asynchrones permettent de ne pas bloquer l'exécution de l'application 
//pendant que des tâches lentes (comme accéder au système de fichiers) sont effectuées.

void main() async {
//await : Attend que l'opération asynchrone (ici getApplicationSupportDirectory()) 
//soit terminée avant de passer à la ligne suivante.
  Directory appSubDir = await getApplicationSupportDirectory();
  String appSubPath = appSubDir.path;
  print('Application Support Directory: $appSubPath');
}

2. getApplicationDocumentDirectory()

• Donne le chemin vers le répertoire dans lequel l’application peut placer ses fichiers privés. Les fichiers ne sont effacés que lorsque l’application elle-même est supprimée.
• Android – renvoie le répertoire AppData .
• iOS – API NSDocumentsDirectory .

  final directory = await getApplicationDocumentsDirectory();

• getApplicationDocumentDirectory() : Utilisé pour accéder au chemin où les documents de candidature sont stockés sur l’appareil. Ce chemin représente le dossier par défaut dans lequel les fichiers associés à l’application sont enregistrés.
• L’utilisation de getApplicationCacheDirectory() nécessite l’importation du package path_provider et l’utilisation d’un objet Directory pour accéder au chemin comme suit :

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

void main() async {
  Directory appDocDir = await getApplicationDocumentsDirectory();
  String appDocPath = appDocDir.path;
  print('Application Documents Directory: $appDocPath');
}

3. getApplicationCacheDirectory()

• Cette propriété permet d’accéder au chemin où le cache associé à l’application est stocké sur l’appareil. Ce chemin peut être utilisé pour stocker les fichiers temporaires dont l’application a besoin pendant une courte période. Les fichiers de ce chemin sont automatiquement supprimés périodiquement par le système.
• L’utilisation de getApplicationCacheDirectory() nécessite l’importation du package path_provider et l’utilisation d’un objet Directory pour accéder au chemin comme suit :

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

void main() async {
  Directory appCacheDir = await getApplicationCacheDirectory();
  String appCachePath = appCacheDir.path;
  print('Application Cache Directory: $appCachePath');
}

4. getExternalStorageDirectory() :

• Cette fonctionnalité est utilisée pour accéder au chemin racine du stockage externe sur l’appareil. Le stockage externe sur l’appareil est représenté par des dossiers tels que la carte SD, si disponible sur l’appareil. Ce chemin peut être utilisé pour accéder et manipuler des fichiers dans un stockage externe.
• L’utilisation de getExternalStorageDirectory() nécessite l’importation du package path_provider et l’utilisation d’un objet Directory pour accéder au chemin comme suit :

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

void main() async {
  Directory? extDir = await getExternalStorageDirectory();
  String extPath = extDir!.path;
  print('External Storage Directory: $extPath');
}

5. getDownloadsDirectory() : :

• Cette propriété est utilisée pour accéder au chemin où le dossier Téléchargements est stocké sur l’appareil. Ce chemin représente le dossier par défaut dans lequel sont enregistrés les fichiers téléchargés depuis Internet ou d’autres applications.
• L’utilisation de getDownloadsDirectory() nécessite d’importer le package path_provider et d’utiliser un objet Directory pour accéder au chemin comme suit :

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

void main() async {
  Directory? downloadsDir = await getDownloadsDirectory();
  String downloadsPath = downloadsDir!.path;
  print('Downloads Directory Path: $downloadsPath');
}

4. Répertoire des documents

• Répertoire des documents : Utilisé pour stocker des fichiers permanents accessibles par l’utilisateur (par exemple, des fichiers téléchargés).
• Méthode : getApplicationDocumentsDirectory().
• Répertoire de stockage externe (Android) : Utilisé pour des fichiers visibles par l’utilisateur à l’extérieur de l’application.
• Méthode : getExternalStorageDirectory().
• Répertoire de cache : Utilisé pour stocker des fichiers que l’application peut recréer ou télécharger à nouveau.
• Méthode : getApplicationSupportDirectory().

5. Exemple d’utilisation :

• Voici comment utiliser path_provider pour récupérer le répertoire des documents dans une application Flutter :
• Ajouter la dépendance dans pubspec.yaml : path_provider: ^2.0.14 # Vérifiez la version la plus récente

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

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: PathProviderExample(),
    );
  }
}

class PathProviderExample extends StatefulWidget {
  @override
  _PathProviderExampleState createState() => _PathProviderExampleState();
}

class _PathProviderExampleState extends State {
  String? _documentsPath;

  @override
  void initState() {
    super.initState();
    _getDocumentsPath();
  }

  Future _getDocumentsPath() async {
    final directory = await getApplicationDocumentsDirectory();
    setState(() {
      _documentsPath = directory.path;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Path Provider Example')),
      body: Center(
        child: Text(
          _documentsPath != null
              ? 'Documents Path: $_documentsPath'
              : 'Fetching documents path...',
        ),
      ),
    );
  }
}

• Explications :
• getApplicationDocumentsDirectory() : Cette méthode retourne un chemin où les fichiers permanents spécifiques à l’application peuvent être stockés.
• Dossiers temporaires et caches : Vous pouvez utiliser getTemporaryDirectory() ou getApplicationSupportDirectory() pour des fichiers moins critiques.
• Applications courantes :
• Enregistrer des fichiers de configuration.
• Gérer les téléchargements ou les fichiers générés localement.
• Lire ou écrire des fichiers JSON ou texte stockés localement.
• Pour des opérations avancées sur les fichiers, vous pouvez combiner path_provider avec la bibliothèque dart:io.