Lire et écrire à partir du disque dans Flutter

Lire et écrire à partir du disque dans Flutter

1. Objectifs

   • Comprendre la Classe path_provider.
   • Utiliser path_provider pour Accéder aux Répertoires.
   • Lire et Écrire des Fichiers:

2. Introduction

   • Dans Flutter, pour enregistrer des fichiers sur le disque, combinez le path_provider plugin avec la dart:io bibliothèque.
   • Cette tâche utilise les étapes suivantes pour lire et écrire à partir du disque.

   1-Tout d'abord, trouvez le bon chemin

   2-Créer une référence à l'emplacement du fichier

   3-Écrire des données dans le fichier

   4-Lire les données du fichier

   5-Commençons par la mise en œuvre

3. Réalisation

   1. Trouvez le chemin local correct

      • Cet exemple stocke les informations dans le répertoire documents. Vous pouvez trouver le chemin d'accès au répertoire documents comme suit :
      • Ajouter une dépendance : path_provider: ^2.0.10

        Future <String> get _localPath async {
            final directory = await getApplicationDocumentsDirectory();
         
            return directory.path;
          }

      • Explication :
        • Future<String> :
          • La fonction _localPath renvoie un Future qui contient une chaîne de caractères (String).
          • Un Future est utilisé pour gérer des opérations asynchrones, c'est-à-dire des opérations qui ne bloquent pas l'exécution du programme (comme l'accès au système de fichiers ou une requête réseau).
          • Le type String spécifie que la valeur retournée, une fois que le Future est résolu, sera un chemin de répertoire sous forme de chaîne de caractères.
        • get _localPath async :
          • Il s'agit d'un getter asynchrone, ce qui signifie qu'il permet d'obtenir la valeur de la variable _localPath de manière asynchrone (sans bloquer l'exécution).
          • Un getter est une méthode qui vous permet de récupérer une valeur comme si c'était une propriété.
          • Le mot-clé async permet d'utiliser await dans cette méthode, ce qui est nécessaire pour gérer les opérations asynchrones.
        • final directory = await getApplicationDocumentsDirectory(); :
          • getApplicationDocumentsDirectory() est une méthode fournie par le package path_provider. Elle retourne le répertoire où vous pouvez stocker des fichiers dans l'application. Ce répertoire est privé à votre application et accessible uniquement à elle.
          • La méthode est asynchrone, donc nous utilisons await pour attendre sa résolution. Cela signifie que le programme attend que le répertoire soit récupéré avant de passer à l'étape suivante.
          • Le résultat de getApplicationDocumentsDirectory() est stocké dans la variable directory, qui est un objet de type Directory.
        • return directory.path; :
          • Une fois que le répertoire est récupéré, nous renvoyons le chemin du répertoire sous forme de chaîne de caractères (directory.path).
          • directory.path contient la localisation complète du répertoire dans le système de fichiers de l'appareil (par exemple, un chemin comme /data/user/0/com.example.app/app_flutter/).
          • Ce chemin est renvoyé au code appelant, qui peut alors utiliser ce chemin pour lire ou écrire des fichiers dans ce répertoire.

   2. Créez une référence à l'emplacement du fichier

      • Une fois que vous savez où stocker le fichier, créez une référence à l'emplacement complet du fichier. Vous pouvez utiliser la File classe de la dart:io bibliothèque pour y parvenir.

        Future <File> get _localFile async {
            final path = await _localPath;
            return File('$path/counter.txt');
          }

   3. Écrire des données dans le fichier

      • Tout d'abord, écrivez quelques données dans le fichier. Le compteur est un entier, mais il est écrit dans le fichier sous forme de chaîne en utilisant la '$counter' syntaxe.
      • Code

        Future<File> writeCounter(int counter) async {
            final file = await _localFile;
         
            // Write the file
            return file.writeAsString('$counter');
          }

   4. Lire les données du fichier

      • Nous avons des données sur le disque, nous pouvons les lire. Encore une fois, utilisez la File classe.

        Future<int> readCounter() async {
            try {
              final file = await _localFile;
         
              // Read the file
              final contents = await file.readAsString();
         
              return int.parse(contents);
            } catch (e) {
              // If encountering an error, return 0
              return 0;
            }
          }

4. Un exemple complet de lecture et d'écriture à partir du disque

   • Créer une application Flutter qui permet :
     • À l'utilisateur d'écrire une note dans un champ de texte.
     • De sauvegarder cette note dans un fichier local.
     • De recharger automatiquement la note enregistrée lorsque l'application est relancée.

     import 'dart:async';
     import 'dart:io';
     import 'package:flutter/material.dart';
     import 'package:path_provider/path_provider.dart';
      
     void main() {
       runApp(
         MaterialApp(
           debugShowCheckedModeBanner: false,
           title: 'Reading and Writing File from disk',
           home: HomePage(storage: IntStorage()),
         ),
       );
     }
      
     class IntStorage {
       Future<String> get _localPath async {
         final directory = await getApplicationDocumentsDirectory();
      
         return directory.path;
       }
      
       Future<File> get _localFile async {
         final path = await _localPath;
         return File('$path/counter.txt');
       }
      
       Future<int> readCounter() async {
         try {
           final file = await _localFile;
      
           // Read the file
           final contents = await file.readAsString();
      
           return int.parse(contents);
         } catch (e) {
           // If encountering an error, return 0
           return 0;
         }
       }
      
       Future<File> writeCounter(int counter) async {
         final file = await _localFile;
      
         // Write the file
         return file.writeAsString('$counter');
       }
     }
      
     class HomePage extends StatefulWidget {
       
       const HomePage({ required this.storage});
      
       final IntStorage storage;
      
       @override
       _HomePageState createState() => _HomePageState();
     }
      
     class _HomePageState extends State {
       int count = 0;
       int savedValue = 0;
       @override
       void initState() {
         super.initState();
         widget.storage.readCounter().then((value) {
           setState(() {
             savedValue = value;
           });
         });
       }
      
       Future<File> _incrementCounter() {
         setState(() {
           count++;
           savedValue++;
         });
      
         // Write the variable as a string to the file.
         return widget.storage.writeCounter(savedValue);
       }
      
       @override
       Widget build(BuildContext context) {
         return Scaffold(
           appBar: AppBar(
             title: const Text('Reading and Writing Files'),
           ),
           body: Center(
      
             child: Column(
               mainAxisAlignment: MainAxisAlignment.center,
               children: [
                 Text(
                   'Value in disk $savedValue time${savedValue == 1 ? '' : 's'}.',style: TextStyle(fontSize: 22),
                 ),
                 Text(
                   'Button tapped $count time${count == 1 ? '' : 's'}.',style: TextStyle(fontSize: 22)
                 ),
                 TextButton(onPressed: (){
                   setState(() {
                     count = 0;
                   });
                 }, child: Text("Refresh"))
               ],
             ),
           ),
           floatingActionButton: FloatingActionButton(
             onPressed: _incrementCounter,
             tooltip: 'Increment',
             child: const Icon(Icons.add),
           ),
         );
       }
     }