[JAVA] * Android * Informationen zum Speichern / Lesen von Dateien in einem externen Speicher und mit Berechtigungen

Einführung

Hallo. In Fortsetzung von Letztes Mal werde ich den Speichervorgang von Android erläutern. Dieses Mal besteht der Inhalt darin, Dateien in einem externen Speicher zu speichern / zu lesen, aber ich werde versuchen, dies so zu realisieren, dass es dem vorherigen Speichern / Lesen des internen Speichers so nahe wie möglich kommt.

Wie ich letztes Mal erwähnt habe, unterscheiden sich alle Artikel über Android-Kommentare geringfügig, und ich denke, dass einige Leute verloren gehen können. Deshalb versuche ich, eine Standardmethode zu schreiben.

Annahme

Die Entwicklungsumgebung ist wie folgt. ＊Android Studio 4.0.1 ＊targetSdkVersion 28 ＊Google Nexus 5x

Speichern / Laden von Dateien in einen externen Speicher

Dieses Mal werden die Dateien im anwendungsspezifischen Bereich (/ sdcard / Android / data / package name / files /) des externen Speichers gespeichert. Wenn Sie Dateien in einem externen Speicher speichern möchten, ist es Standard, sie an diesem Speicherort zu speichern.

Ab Android 6.0 (API-Level 23) überprüfen Benutzer die Berechtigung nach dem Start der App, nicht bei der Installation der App. Zum Lesen und Schreiben von externem Speicher ist eine Berechtigung erforderlich.

In Bezug auf die Erlaubnis

Bei der Entwicklung von Android-Apps verfügt Permission über zwei Schutzstufen: "Normal" und "Gefährlich". Da die Schutzstufe für jede Berechtigung festgelegt wird, ist es erforderlich, die für Normal erforderliche Verarbeitung und die für Gefährlich erforderliche Verarbeitung gemäß der erforderlichen Berechtigung zu implementieren.

Verarbeitung für normale Berechtigung erforderlich

Für die normale Berechtigung müssen Sie lediglich die Berechtigung in AndroidManifest.xml beschreiben. Beispielsweise ist eine normale Berechtigung erforderlich, um mit einer Android-App eine Verbindung zum Internet herzustellen.

AndroidManifest.xml

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

Fügen Sie einfach eine Zeile wie oben hinzu und Sie können eine Verbindung zum Internet herstellen.

Verarbeitung für gefährliche Genehmigung erforderlich

Diesmal ist eine Verarbeitung gefährlicher Berechtigungen erforderlich, um externen Speicher zu lesen und zu schreiben. Beschreiben Sie zunächst die Berechtigung in AndroidManifest.xml.

AndroidManifest.xml

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

Als Nächstes müssen Sie die Berechtigungsprüfung implementieren. Wenn die App geöffnet wird, kann der Benutzer ein Dialogfeld bezüglich der Berechtigung / Nichtberechtigung der Berechtigung anzeigen. Bitte beziehen Sie sich auf das Beispielprogramm, da die Verarbeitung langwierig sein wird.

Speichern von Dateien in einem externen Speicher

Rufen Sie zunächst den Pfad zu dem Ordner ab, den Sie im externen Speicher speichern möchten, und erstellen Sie den Pfad einschließlich des Dateinamens.

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

Infolgedessen wird der Dateivariablen die Zeichenfolge "/ sdcard / Android / data / Paketname / files / Documents / test.txt" zugewiesen.

Um zu überprüfen, ob der externe Speicher derzeit lesbar und beschreibbar ist, schreiben Sie vor dem Lese- / Schreibvorgang Folgendes.

String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)){
    //Datei Lese- / Schreibverarbeitung
}

Als nächstes wird die Datei gespeichert. Beim Speichern einer Datei im internen Speicher wurde der Pfad zum internen Speicher automatisch mithilfe der Methode openFileOutput () für die Instanz von FileOutputStream angegeben. Diesmal verwende ich jedoch nicht `openFileOutput ()`, da ich den Pfad des externen Speichers selbst angeben muss.

FileOutputStream fileOutputStream = new FileOutputStream(file, true);

** Erstes Argument ** "/Pfad/Dateiname"

** Zweites Argument ** trueWenn festgelegt, wird es am Ende der Datei geschrieben. falseWenn angegeben, wird die Datei von Anfang an überschrieben.

Konvertieren Sie anschließend die Zeichenfolge, die Sie in die Datei schreiben möchten, in ein Array vom Typ Byte und schreiben Sie sie mit `write ()` in den Stream.

fileOutputStream.write(str.getBytes());

Lesen Sie Dateien aus dem externen Speicher

Beim Lesen einer Datei erhalten Sie eine Instanz von `` `FileInputStream```. Auf diese Weise können Sie den Stream öffnen.

FileInputStream fileInputStream = new FileInputStream(file);

Die nachfolgende Verarbeitung entspricht der von Letztes Mal.

Beispielcode

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++){
            //Das erste Mal ist die ERLAUBNIS_VERWEIGERT kehrt zurück
            if (checkSelfPermission(PERMISSIONS[i]) != PackageManager.PERMISSION_GRANTED) {
                //Gibt true zurück, wenn die Anforderung einmal abgelehnt wird. Gibt zum ersten Mal false zurück oder wenn "Nicht mehr anzeigen" ausgewählt ist.
                if (shouldShowRequestPermissionRationale(PERMISSIONS[i])) {
                    Toast.makeText(this, "Zum Ausführen der App ist eine Berechtigung erforderlich", 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;
    }
}