Voorbeeld Tutorial Android Interne Opslag

Android

Vandaag zullen we kijken naar de interne opslag van Android. Android biedt een paar gestructureerde manieren om gegevens op te slaan. Deze omvatten

Gedeelde Voorkeuren
Interne opslag
Externe opslag
SQLite opslag
Opslag via netwerkverbinding (op de cloud)

In deze tutorial gaan we kijken naar het opslaan en lezen van gegevens in bestanden met behulp van Android Interne Opslag.

Android Interne Opslag

Android Interne opslag is de opslag van privégegevens in het geheugen van het apparaat. Standaard zijn het opslaan en laden van bestanden naar de interne opslag privé voor de applicatie en andere applicaties zullen geen toegang hebben tot deze bestanden. Wanneer de gebruiker de applicaties verwijdert, worden ook de intern opgeslagen bestanden die bij de applicatie horen verwijderd. Let echter op dat sommige gebruikers hun Android-telefoons rooten, waardoor ze supergebruikerstoegang krijgen. Deze gebruikers zullen in staat zijn om te lezen en schrijven wat voor bestanden ze ook willen.

Het lezen en schrijven van tekstbestanden in de interne opslag van Android

Android biedt openFileInput en openFileOutput vanuit de Java I/O-klassen om lees- en schrijfstromen van en naar lokale bestanden te wijzigen.

openFileOutput(): Deze methode wordt gebruikt om een bestand te maken en op te slaan. De syntaxis is als volgt:
```
FileOutputStream fOut = openFileOutput("bestandsnaam",Context.MODE_PRIVATE);
```
De methode openFileOutput() retourneert een instantie van FileOutputStream. Daarna kunnen we de write-methode aanroepen om gegevens naar het bestand te schrijven. De syntaxis is als volgt:
```
String str = "testgegevens";
fOut.write(str.getBytes());
fOut.close();
```
openFileInput(): Deze methode wordt gebruikt om een bestand te openen en te lezen. Het retourneert een instantie van FileInputStream. De syntaxis is hieronder gegeven:
```
FileInputStream fin = openFileInput(file);
```
Daarna roepen we de read-methode aan om telkens één karakter uit het bestand te lezen en vervolgens af te drukken. De syntaxis is als volgt:
```
int c;
String temp="";
while( (c = fin.read()) != -1){
   temp = temp + Character.toString((char)c);
}

fin.close();
```
In de bovenstaande code bevat de string temp alle gegevens van het bestand.
Merk op dat deze methoden geen bestandspaden accepteren (bijv. pad/naar/bestand.txt), ze nemen alleen eenvoudige bestandsnamen.

Structuur van het Android Interne Opslagproject

Voorbeeldcode voor Android interne opslag

Het xml-layout bevat een EditText om gegevens naar het bestand te schrijven en een knop Schrijven en Lezen. Let op dat de onClick-methoden alleen in het xml-bestand zijn gedefinieerd zoals hieronder wordt getoond: activity_main.xml

<RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
    xmlns:tools="https://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentRight="true"
        android:padding="5dp"
        android:text="Android Read and Write Text from/to a File"
        android:textStyle="bold"
        android:textSize="28sp" />

    <EditText
        android:id="@+id/editText1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentRight="true"
        android:layout_below="@+id/textView1"
        android:layout_marginTop="22dp"
        android:minLines="5"
        android:layout_margin="5dp">

        <requestFocus />
    </EditText>

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Write Text into File"
        android:onClick="WriteBtn"
        android:layout_alignTop="@+id/button2"
        android:layout_alignRight="@+id/editText1"
        android:layout_alignEnd="@+id/editText1" />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Read Text From file"
        android:onClick="ReadBtn"
        android:layout_centerVertical="true"
        android:layout_alignLeft="@+id/editText1"
        android:layout_alignStart="@+id/editText1" />

</RelativeLayout>

De MainActivity bevat de implementatie van het lezen en schrijven naar bestanden zoals hierboven uitgelegd.

package com.journaldev.internalstorage;


import android.os.Bundle;
import android.app.Activity;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class MainActivity extends Activity {

    EditText textmsg;
    static final int READ_BLOCK_SIZE = 100;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textmsg=(EditText)findViewById(R.id.editText1);
    }

    
// tekst naar bestand schrijven

    public void WriteBtn(View v) {
        
// tekst toevoegen aan bestand

        try {
            FileOutputStream fileout=openFileOutput("mytextfile.txt", MODE_PRIVATE);
            OutputStreamWriter outputWriter=new OutputStreamWriter(fileout);
            outputWriter.write(textmsg.getText().toString());
            outputWriter.close();

            
// weergave bestand opgeslagen bericht

            Toast.makeText(getBaseContext(), "File saved successfully!",
                    Toast.LENGTH_SHORT).show();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
// tekst uit bestand lezen

    public void ReadBtn(View v) {
        
// tekst uit bestand lezen

        try {
            FileInputStream fileIn=openFileInput("mytextfile.txt");
            InputStreamReader InputRead= new InputStreamReader(fileIn);

            char[] inputBuffer= new char[READ_BLOCK_SIZE];
            String s="";
            int charRead;

            while ((charRead=InputRead.read(inputBuffer))>0) {
                
// karakter naar string conversie

                String readstring=String.copyValueOf(inputBuffer,0,charRead);
                s +=readstring;
            }
            InputRead.close();
            textmsg.setText(s);
            

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Hier wordt een toast weergegeven wanneer gegevens succesvol zijn geschreven naar de interne opslag en de gegevens worden weergegeven in de EditText zelf bij het lezen van de gegevens uit het bestand. De onderstaande afbeelding toont de uitvoer van het project. De afbeelding laat zien dat tekst naar de interne opslag wordt geschreven en bij het klikken op Lezen wordt de tekst terug weergegeven in dezelfde EditText.

Waar bevindt het bestand zich?

Om het bestand daadwerkelijk te bekijken, opent u de Android Device Monitor vanuit Tools->Android->Android Device Monitor. Het bestand bevindt zich in de map data->data->{pakketnaam}->bestanden zoals getoond in de afbeeldingen hieronder: Het bestand “mytextfile.txt” is te vinden in de pakketnaam van het project, namelijk com.journaldev.internalstorage zoals hieronder getoond: Download het eindproject voor voorbeeld van interne opslag voor Android vanaf onderstaande link.

Download Android Internal Storage Example Project

Source:
https://www.digitalocean.com/community/tutorials/android-internal-storage-example-tutorial