Stockage interne

Détails
Catégorie : Persistance des données
Affichages : 4

Stockage interne

 Lorsque vous devez travailler avec des types plus complexes tels que audio, vidéo ou images, vous pouvez utiliser le stockage interne (mémoire interne du périphérique) ou externe (mémoire accessible au public, par exemple, SDCARD). Un stockage externe peut Être accessible par l'application qui l'a créée, par d'autres applications et même par l'utilisateurn survivre à l'application, même après sa désinstallation Un stockage interneEst accessible uniquement par l'application qui l'a créé; aucune autre application ne peut y accéderSera supprimé lors de la désinstallation de l'application Dans ce chapitre, nous ne travaillerons qu'avec le stockage interne.

 Comment travailler avec le stockage interne

 Pour enregistrer des données sur un stockage interne, nous devons d’abord créer un objet FileInputStream; cela peut être géré par la méthode openFileInput de la classe Activity. Lorsqu'un fichier est ouvert en écriture, tout son contenu précédent est supprimé. Il est toutefois possible d'ouvrir un fichier de manière à pouvoir ajouter un nouveau contenu, en préservant ainsi le contenu précédent.

 FileOutputStream fout = openFileOutput(<name of file>,  Context.MODE_APPEND);

 Si vous ne voulez pas ouvrir le fichier en mode ajout, passez simplement Context.MODE_PRIVATE comme second paramètre. Une fois le fichier préparé, nous pouvons lui écrire des données. fout.write (<données de chaîne>); Les méthodes openFileOutput et write peuvent toutes deux générer des exceptions. Elles doivent donc être gérées en renvoyant l'exception ou en la utilisant à l'aide d'une construction try-catch. Dans notre exemple, nous avons utilisé les blocs try-catch pour gérer les exceptions possibles. La lecture de données depuis une mémoire interne est également simple. Cela ressemble beaucoup au processus d’écriture de données; nous devons simplement préparer un FileInputStream puis le lire.

 FileInputStream fin = openFileInput(<name of file>);

The file input is a stream. The basic idea is to read bytes from it a chunk at a time until we reach the end of the file.

Let’s explore the details in a demo project.

Demonstration du Projet

 Nous montrerons comment développer l’application de stockage interne comme indiqué dans le tableau 10-4. 

Table 10-4. Project details for InternalStorage

Application name

InternalStorage

Project location

Use the default

Form factor

Phone and tablet only

Minimum SDK

API 23 Marshmallow

Type of activity

Empty

Activity name

MainActivity (default)

Layout name

activity_main (default)

Les détails relatifs à la configuration du fichier de présentation unique (activity_main) sont illustrés à la Figure 10-13 et au Listing 10-12.

 

Figure 10-13. activity_main

Le fichier de présentation est typique de notre projet de démonstration habituel, mais il convient de souligner les points suivants. 1. Le EditText étant censé capturer plusieurs lignes de texte, vous devez donc définir son attribut «inputType» sur «textMultiline». Vous pouvez le faire dans la fenêtre de l'inspecteur d'attributs en mode conception, ou bien écrire directement dans le fichier XML, comme indiqué dans le Listing 10-12.2. Nous n'allons pas gérer les événements de clic par programmation, nous avons donc défini les valeurs pour les attributs «onClick» des deux boutons.

 Listing 10-12. activity_main.xml

  1. <?xml version="1.0" encoding="utf-8"?>

  2.  
  3. <android.support.constraint.ConstraintLayout

  4.  
  5.   xmlns:android="http://schemas.android.com/apk/res/android"

  6.  
  7.    xmlns:app="http://schemas.android.com/apk/res-auto"

  8.  
  9.    xmlns:tools="http://schemas.android.com/tools"

  10.  
  11.    android:layout_width="match_parent"

  12.  
  13.    android:layout_height="match_parent"

  14.  
  15.   tools:context="com.example.ted.internalstorage.MainActivity">

 

Data Persistence

 

  1.   <EditText

  2.  
  3.      android:id="@+id/edittext"

  4.  
  5.      android:layout_width="359dp"

  6.  
  7.      android:layout_height="193dp"

  8.  
  9.      android:layout_marginEnd="16dp"

  10.  
  11.      android:layout_marginLeft="16dp"

  12.  
  13.      android:layout_marginTop="16dp"

  14.  
  15.      android:ems="10"

  16.  
  17.      android:inputType="textMultiLine"

  18.  
  19.      //This makes it multiline

  20.  
  21.      app:layout_constraintEnd_toEndOf="parent"

  22.  
  23.      app:layout_constraintLeft_toLeftOf="parent"

  24.  
  25.      app:layout_constraintTop_toTopOf="parent"/>

  26.  
  27.   <Button

  28.  
  29.     android:id="@+id/btnsave"

  30.  
  31.      android:layout_width="wrap_content"

  32.  
  33.      android:layout_height="wrap_content"

  34.  
  35.      android:layout_marginLeft="24dp"

  36.  
  37.      android:layout_marginTop="11dp"

  38.  
  39.      android:onClick="saveData"

  40.  
  41.      android:text="Save"

  42.  
  43.      app:layout_constraintLeft_toLeftOf="parent"

  44.  
  45.      app:layout_constraintTop_toBottomOf="@+id/edittext"/>

  46.  
  47.   <Button

  48.  
  49.      android:id="@+id/btnload"

  50.  
  51.      android:layout_width="wrap_content"

  52.  
  53.      android:layout_height="wrap_content"

  54.  
  55.      android:layout_marginStart="21dp"

  56.  
  57.      android:layout_marginTop="11dp"

  58.  
  59.      android:onClick="loadData"

  60.  
  61.      android:text="Load"

  62.  
  63.     app:layout_constraintStart_toEndOf="@+id/btnsave"

  64.  
  65.      app:layout_constraintTop_toBottomOf="@+id/edittext"/>

  66.  
  67.   <TextView

  68.  
  69.     android:id="@+id/textview"

  70.  
  71.      android:layout_width="360dp"

  72.  
  73.      android:layout_height="0dp"

  74.  
  75.      android:layout_marginBottom="9dp"

  76.  
  77.      android:layout_marginLeft="16dp"

  78.  
  79.      android:layout_marginTop="14dp"

  80.  
  81.      android:text="TextView"

  82.  
  83.     app:layout_constraintBottom_toBottomOf="parent"

  84.  
  85.      app:layout_constraintLeft_toLeftOf="parent"

  86.  
  87.      app:layout_constraintTop_toBottomOf="@+id/btnsave"/> </android.support.constraint.ConstraintLayout>

 Le Listing 10-13 montre la structure de MainActivity. La méthode saveData est associée au bouton “SAVE” et loadData est associée au bouton “LOAD”.

 Listing 10-13. Overview of MainActivity

 

  1. public class MainActivity extends AppCompatActivity {   EditText editText;    
  2.  
  3.   private String filename = "myfile.txt";
  4.  
  5.   @Override
  6.  
  7.   protected void onCreate(Bundle savedInstanceState) {
  8.  
  9.     super.onCreate(savedInstanceState);
  10.  
  11.      setContentView(R.layout.activity_main);
  12.  
  13.      editText = (EditText) findViewById(R.id.edittext);
  14.  
  15.    }
  16.  
  17.    public void saveData(View v) { ... }
  18.  
  19.    public void loadData(View v) { ... }
  20.  
  21. }

ditText est défini en tant que variable membre car nous devrons y faire référence à partir de saveData et de loadData.Le nom de fichier est défini en tant que variable membre pour la même raison que dans no. 1

Listing 10-14. Code for saveData

 

  1. public void saveData(View v) {
  2.  
  3.    String str = editText.getText().toString();
  4.  
  5.   FileOutputStream out = null;
  6.  
  7.   try {
  8.  
  9.     out = openFileOutput(filename, Context.MODE_APPEND); 
  10.  
  11.    out.write(str.getBytes());
  12.  
  13.    } catch (FileNotFoundException e) {
  14.  
  15.     e.printStackTrace();
  16.  
  17.     // You should do more logging here
  18.  
  19.   } catch (IOException e) {
  20.  
  21.     e.printStackTrace();
  22.  
  23.   }   finally {
  24.  
  25.     if (out != null) {   
  26.  
  27.      try { 
  28.  
  29.         out.close();     
  30.  
  31.        } catch (IOException e) {
  32.  
  33.         e.printStackTrace();
  34.  
  35.       }
  36.  
  37.     }
  38.  
  39.   }
  40.  
  41. }

 openFileOutput prépare un fichier pour l'écriture. Le premier argument est le nom du fichier à créer et le second argument détermine si nous pouvons ajouter au fichier ou s'il sera écrasé à chaque ouverture du fichier. Dans ce cas, nous avons choisi le mode Ajout afin de pouvoir conserver le contenu original du fichier. Cette méthode peut générer une «FileNotFoundException»; c’est pourquoi il doit être entouré d’un bloc try-catchEffectue l'écriture réelle des données sur le disque. Cela ne peut fonctionner qu'avec des octets, cependant; c’est pourquoi nous avions besoin de la méthode getBytes. Cette méthode peut générer une “IOException”; c’est pourquoi nous avons dû préciser cela dans la clause de captureNous devons savoir que l'objet FileOutputStream n'est pas null avant de poursuivre. Cela ferme le fichier et libère les ressources système qui lui sont associées. Cette méthode peut générer une «IOException», d’où la nécessité d’une construction imbriquée try-catch 

Listing 10-15. Code for loadData

 

  1. public void loadData(View v) {
  2.  
  3.   TextView tv = (TextView) findViewById(R.id.textview);
  4.  
  5.   FileInputStream in = null;
  6.  
  7.   StringBuilder sb = new StringBuilder();
  8.    try {
  9.  
  10.     in = openFileInput(filename);
  11.       int read = 0;
  12.  
  13.     while((read = in.read()) != -1) {
  14.        sb.append((char) read);
  15.      }
  16.      tv.setText(sb.toString());
  17.  
  18.   } catch (FileNotFoundException e) {
  19.  
  20.     e.printStackTrace();
  21.  
  22.   } catch (IOException e) {
  23.  
  24.     e.printStackTrace();
  25.  
  26.   }
  27.    finally {
  28.      if (in != null) {
  29.  
  30.       try {
  31.          in.close();
  32.  
  33.       } catch (IOException e) {
  34.  
  35.         e.printStackTrace();
  36.  
  37.       }
  38.  
  39.     }
  40.  
  41.   }
  42.  
  43. }

 Préparez le fichier pour le lire. Cette méthode peut générer une «FileNotFoundException»; c'est pourquoi il doit être entouré d'un bloc try-catch, comme openFileOuput. La méthode de lecture du flux d'entrée lit un octet de données à la fois, et lorsqu'elle atteint la fin du fichier où il n'y a plus rien à lire, elle retour -1La méthode in.read () renvoie un int; nous devons le convertir en caractère afin que nous puissions utiliser StringBuilderLorsque nous arrivons à la fin du fichier, nous pouvons convertir l'objet StringBuilder en String et le définir comme texte pour la vue Texte.Vous pouvez inspecter le contenu du ou des fichiers de stockage interne en utilisant Android Device Monitor. Le fichier se trouve dans les données - données <package de projet + nom>.