La classe path_provider dans Flutter

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).

Introduction

flutter_path_provider

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.

Installation et configuration

Vous pouvez suivre les étapes ci-dessous pour commencer à utiliser le package PathProvider :
1. Ajoutez le package path_provider au fichier pubspec.yaml :

dependencies: flutter: sdk: flutter path_provider: ^2.0.15

Vous pouvez également le faire en effectuant l’une des étapes suivantes :

Appuyez sur Ctrl+Maj+p puis cliquez sur ajouter une dépendance.
Ou
Exécutez simplement la commande suivante sur votre terminal :

flutter pub get path_provider

2. Importez le package PathProvider

Dans le fichier où vous souhaitez utiliser PathProvider, vous devez d’abord importer le package comme suit :

import 'package:path_provider/path_provider.dart';

3. Chemins d’accès au répertoire

Maintenant, après avoir ajouté le package à notre pubspec.yaml et l’avoir importé dans notre fichier dart, nous pouvons utiliser le package PathProvider pour accéder aux chemins de répertoire. Les cas d’utilisation de base pour cela sont présentés dans la section suivante.

Méthodes path_provider

Le package PathProvider de Flutter propose plusieurs méthodes pour travailler avec des fichiers et des répertoires.
Le package PathProvider de Flutter nous fournit diverses méthodes qui nous permettent, en tant que développeurs, de travailler très facilement avec des fichiers et des répertoires.

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');`

getTemporaryDirectory()

getTemporaryDirectory() est une méthode de Flutter qui renvoie un répertoire dans lequel l’application peut stocker des fichiers temporaires. Ces fichiers peuvent être supprimés par le système à tout moment, ils ne doivent donc pas être utilisés pour stocker des données importantes. Ceci est généralement utilisé pour la mise en cache de fichiers qui peuvent être régénérés s’ils sont supprimés.
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'); }

getApplicationDocumentDirectory()

getApplicationDocumentsDirectory() est une méthode dans Flutter qui renvoie un répertoire dans lequel l’application peut stocker les fichiers destinés à être conservés lors des lancements de l’application. Ces fichiers seront supprimés lors de la désinstallation de l’application.
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'); }

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'); }

getExternalStorageDirectory() :

getExternalStorageDirectory() est une méthode dans Flutter qui renvoie le répertoire de stockage externe principal de l’appareil. Ce répertoire est généralement utilisé pour stocker des fichiers destinés à être partagés avec d’autres applications ou à persister lors des lancements d’applications. Le chemin renvoyé peut ne pas être accessible si le stockage externe n’est pas disponible ou si l’application ne dispose pas des autorisations nécessaires pour y accéder.
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'); }

getExternalCacheDirectories() : :

getExternalCacheDirectories() : getExternalCacheDirectories() est une méthode dans Flutter qui renvoie une liste de répertoires dans lesquels une application peut stocker des fichiers de cache sur des périphériques de stockage externes, tels qu’une carte SD. Cette méthode est utile pour les applications qui doivent stocker des données temporaires qui peuvent être régénérées en cas de suppression. La méthode renvoie une liste de répertoires, au cas où l’appareil dispose de plusieurs options de stockage externe. Il est important de noter que les chemins renvoyés peuvent ne pas être accessibles si le stockage externe n’est pas disponible, ou si l’application ne dispose pas des autorisations nécessaires pour y accéder, et que les fichiers du cache peuvent être supprimés par le système à tout moment.

getLibraryDirectory() : :

getLibraryDirectory() : getLibraryDirectory()est une méthode du système d’exploitation Android qui renvoie le chemin d’accès au répertoire de l’appareil dans lequel l’application peut placer les fichiers persistants dont elle est propriétaire. Ce répertoire est interne à l’application et n’est pas accessible aux autres applications (ni à l’utilisateur). Il est particulièrement adapté aux fichiers avec lesquels l’utilisateur n’a pas besoin d’interagir directement.

getDownloadsDirectory() : :

getDownloadsDirectory() est une méthode dans Flutter qui renvoie le répertoire de téléchargement de l’appareil, où l’utilisateur peut généralement trouver les fichiers qu’il a téléchargés via Internet ou d’autres applications. Ce répertoire est souvent utilisé par les applications qui doivent télécharger et stocker des fichiers tels que des images, des vidéos, des documents, etc. Il est important de noter que le chemin renvoyé peut ne pas être accessible si l’application ne dispose pas des autorisations nécessaires pour y accéder.
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'); }

Travailler avec des fichiers et des répertoires

Le package PathProvider de Flutter propose plusieurs méthodes pour travailler avec des fichiers et des répertoires. Le package PathProvider de Flutter nous fournit diverses méthodes qui nous permettent, en tant que développeurs, de travailler très facilement avec des fichiers et des répertoires.
Dans cette section, nous examinerons ces opérations une par une.

Création des répertoires

Nous utilisons la classe Directory pour créer un répertoire dans un chemin spécifique. Un nouveau répertoire est créé en utilisant la méthode getApplicationDocumentsDirectory().

Nous stockons ce répertoire dans un objet appDocDir de type File Directory. Nous stockons maintenant le chemin du répertoire que nous voulons créer dans une chaîne nommée DirPath . Enfin, en appelant Directory(DirPath), le nouveau répertoire est créé.

Directory appDocDir = await getApplicationDocumentsDirectory(); String DirPath = '${appDocDir.path}/new_directory'; Directory newDirectory = Directory(DirPath); newDirectory.create();

Lecture des fichiers

Nous utilisons la méthode readAsString pour lire le contenu d’un fichier. L’ objet f de type File contient le chemin du fichier que nous souhaitons lire. L’objet String du nom fileContent utilise la méthode readAsString() pour obtenir le contenu du f .

File f = File('$documentsPath/my_file.txt'); String fileContent = await f.readAsString();

Écriture dans les fichiers

La méthode writeAsString fonctionne de manière similaire à celle illustrée dans l’exemple ci-dessus.

File f = File('$documentsPath/my_file.txt'); String content = 'Hello, Scaler Topics this side!'; f.writeAsString(content);

Suppression des fichiers et des répertoires

Nous pouvons utiliser la méthode delete() pour supprimer les fichiers et les répertoires et les retirer du système. Pour supprimer le fichier, nous passons le chemin dans un objet nommé f de type File et appelons la fonction delete. Nous supprimons de la même manière les répertoires. Veuillez noter que dans la méthode delete, nous définissons le paramètre recursive sur true. Cela permet d’effectuer la suppression de manière récursive.

File f = File('$documentsPath/my_file.txt'); f.delete(); // Deleting a directory and its contents Directory dir = Directory('$documentsPath/my_directory'); dir.delete(recursive: true);

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.

Flutter

La classe path_provider dans Flutter