[JAVA] * Android * À propos de l'enregistrement / de la lecture de fichiers sur un stockage externe et des autorisations

introduction

Bonjour. Dans la continuité de Dernière fois, je vais vous expliquer le fonctionnement de stockage d'Android. Cette fois, le contenu est de sauvegarder / lire le fichier sur le stockage externe, mais je vais essayer de le réaliser de la même manière que lors de la sauvegarde / lecture précédente du stockage interne.

Comme je l'ai mentionné la dernière fois, tous les articles sur les commentaires Android sont légèrement différents, et je pense que certaines personnes peuvent se perdre, alors j'essaie d'écrire une méthode standard.

supposition

L'environnement de développement est le suivant. ＊Android Studio 4.0.1 ＊targetSdkVersion 28 ＊Google Nexus 5x

Enregistrer / charger des fichiers sur un stockage externe

Cette fois, les fichiers sont enregistrés dans la zone spécifique à l'application (/ sdcard / Android / data / nom du package / files /) du stockage externe. Lorsqu'il s'agit d'enregistrer des fichiers sur un stockage externe, il est standard de les enregistrer à cet emplacement.

À partir d'Android 6.0 (niveau d'API 23), les utilisateurs vérifieront l'autorisation après le lancement de l'application, pas lors de l'installation de l'application. Une autorisation est requise pour lire et écrire sur le stockage externe.

Concernant l'autorisation

Dans le développement d'applications Android, Permission dispose de deux niveaux de protection, appelés respectivement Normal et Dangereux. Puisque le niveau de protection est déterminé pour chaque autorisation, il est nécessaire de mettre en œuvre le traitement requis pour Normal et le traitement requis pour Dangereux conformément à l'autorisation requise.

Traitement requis pour une autorisation normale

Tout ce que vous devez faire pour l'autorisation normale est de décrire l'autorisation dans AndroidManifest.xml. Par exemple, une autorisation normale est requise pour se connecter à Internet avec une application Android.

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />

Ajoutez simplement une ligne comme celle ci-dessus et vous pourrez vous connecter à Internet.

Traitement requis pour une autorisation dangereuse

Le traitement des autorisations dangereuses est requis pour la lecture et l'écriture du stockage externe cette fois. Tout d'abord, décrivez l'autorisation dans AndroidManifest.xml.

AndroidManifest.xml

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

Ensuite, nous devons implémenter une vérification des autorisations. Lorsque l'application est ouverte, l'utilisateur peut afficher une boîte de dialogue concernant l'autorisation / la non-autorisation d'autorisation. Veuillez vous référer à l'exemple de programme car le traitement sera long.

Enregistrement de fichiers sur un stockage externe

Tout d'abord, obtenez le chemin d'accès au dossier que vous souhaitez enregistrer dans le stockage externe et créez le chemin avec le nom du fichier.

this.fileName = "test.txt";
this.path = getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS).toString();
this.file = this.path + "/" + this.fileName;

En conséquence, la chaîne de caractères "/ sdcard / Android / data / package name / files / Documents / test.txt" est affectée à la variable de fichier.

Pour vérifier si le stockage externe est actuellement lisible et inscriptible, écrivez ce qui suit avant le processus de lecture / écriture.

String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)){
    //Traitement de lecture / écriture de fichier
}

Vient ensuite le processus d'enregistrement du fichier. Lors de l'enregistrement d'un fichier dans la mémoire interne, le chemin d'accès à la mémoire interne était automatiquement spécifié en utilisant la méthode openFileOutput () `` `pour l'instance de`` `FileOutputStream. Cependant, cette fois je n'utilise pas ```openFileOutput () `` `parce que je dois spécifier moi-même le chemin du stockage externe.

FileOutputStream fileOutputStream = new FileOutputStream(file, true);

** Premier argument ** "/chemin/nom de fichier"

** Deuxième argument ** trueSi est défini, il sera écrit à la fin du fichier. falseSi est spécifié, le fichier sera écrasé depuis le début.

Après cela, convertissez la chaîne de caractères que vous souhaitez écrire dans le fichier en un tableau de type d'octets et écrivez-la dans le flux en utilisant write () '' ``.

fileOutputStream.write(str.getBytes());

Lire des fichiers depuis un stockage externe

Lors de la lecture d'un fichier, vous obtenez une instance de `` FileInputStream ''. Cela vous permettra d'ouvrir le flux.

FileInputStream fileInputStream = new FileInputStream(file);

Le traitement suivant est identique à Dernière fois.

Exemple de code

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.keita.myapplication">
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">


    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="50dp"
        android:layout_marginTop="100dp"
        android:text="Save File"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="100dp"
        android:layout_marginTop="100dp"
        android:text="Read File"
        app:layout_constraintStart_toEndOf="@+id/button1"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="120dp"
        android:text=""
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/editText" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="30dp"
        android:ems="10"
        android:inputType="textPersonName"
        android:text="Name"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

MainActivity.java

package com.example.keita.myapplication;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Environment;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class MainActivity extends AppCompatActivity {
    private String file;
    private String path;
    public String state;
    private String fileName;
    private TextView textView;
    private Button button1;
    private Button button2;
    private EditText editText;
    private final String[] PERMISSIONS = {
            Manifest.permission.WRITE_EXTERNAL_STORAGE
    };
    private final int REQUEST_PERMISSION = 1000;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        this.textView = findViewById(R.id.textView);
        this.editText = findViewById(R.id.editText);
        this.button1 = findViewById(R.id.button1);
        this.button2 = findViewById(R.id.button2);
        this.fileName = "test.txt";
        this.path = getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS).toString();
        this.file = this.path + "/" + this.fileName;

        checkPermission();
    }

    private void checkPermission(){
        if (isGranted()){
            setEvent();
        }
        else {
            requestPermissions(PERMISSIONS, REQUEST_PERMISSION);
        }
    }


    private boolean isGranted(){
        for (int i = 0; i < PERMISSIONS.length; i++){
            //La première fois, c'est PERMISSION_Retours REFUSÉS
            if (checkSelfPermission(PERMISSIONS[i]) != PackageManager.PERMISSION_GRANTED) {
                //Renvoie true si la demande est rejetée une fois. Renvoie false pour la première fois ou lorsque "Ne plus afficher" est sélectionné.
                if (shouldShowRequestPermissionRationale(PERMISSIONS[i])) {
                    Toast.makeText(this, "Autorisation requise pour exécuter l'application", Toast.LENGTH_LONG).show();
                }
                return false;
            }
        }
        return true;
    }


    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_PERMISSION){
            checkPermission();
        }
    }


    private void setEvent(){
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String text = editText.getText().toString();
                state = Environment.getExternalStorageState();
                if (Environment.MEDIA_MOUNTED.equals(state)){
                    saveFile(file, text);
                }
            }
        });

        button2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                state = Environment.getExternalStorageState();
                if (Environment.MEDIA_MOUNTED.equals(state)){
                    String str = readFile(file);
                    textView.setText(str);
                }
            }
        });
    }


    private void saveFile(String file, String str){
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file, true);
            fileOutputStream.write(str.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private String readFile(String file){
        String text = null;
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream, "UTF-8"));
            String lineBuffer;
            while (true){
                lineBuffer = reader.readLine();
                if (lineBuffer != null){
                    text += lineBuffer;
                }
                else {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return text;
    }
}