Auf app-spezifische Dateien zugreifen

In vielen Fällen erstellt Ihre App Dateien, auf die andere Apps nicht zugreifen müssen oder sollten. Das System bietet die folgenden Speicherorte für solche app-spezifischen Dateien:

• Verzeichnisse im internen Speicher:Diese Verzeichnisse umfassen sowohl einen dedizierten Speicherort für nichtflüchtige Dateien als auch einen weiteren Speicherort für Cache-Daten. Das System verhindert, dass andere Apps auf diese Speicherorte zugreifen. Unter Android 10 (API-Level 29) und höher sind diese Speicherorte verschlüsselt. Diese Eigenschaften machen diese Speicherorte zu einem guten Ort für vertrauliche Daten, auf die nur Ihre App selbst zugreifen kann.

• Verzeichnisse im externen Speicher:Diese Verzeichnisse umfassen sowohl einen dedizierten Speicherort für nichtflüchtige Dateien als auch einen weiteren Speicherort für Cache-Daten. Obwohl eine andere App auf diese Verzeichnisse zugreifen kann , wenn sie die entsprechenden Berechtigungen hat, sind die in diesen Verzeichnissen gespeicherten Dateien nur für die Verwendung durch Ihre App vorgesehen. Wenn Sie speziell Dateien erstellen möchten , auf die andere Apps zugreifen können sollen, sollte Ihre App diese Dateien in dem freigegebenen Speicherbereich des externen Speichers speichern.

Wenn der Nutzer Ihre App deinstalliert, werden die in app-spezifischem Speicher gespeicherten Dateien entfernt. Aus diesem Grund sollten Sie diesen Speicher nicht verwenden, um etwas zu speichern, das unabhängig von Ihrer App bestehen bleiben soll. Wenn Ihre App beispielsweise Nutzern das Aufnehmen von Fotos ermöglicht, erwarten sie, dass sie auch nach der Deinstallation Ihrer App auf diese Fotos zugreifen können. Daher sollten Sie stattdessen freigegebenen Speicher verwenden, um diese Arten von Dateien in der entsprechenden Mediensammlungzu speichern.

In den folgenden Abschnitten wird beschrieben, wie Sie Dateien in app-spezifischen Verzeichnissen speichern und darauf zugreifen.

Zugriff über den internen Speicher

Für jede App stellt das System Verzeichnisse im internen Speicher bereit, in denen eine App ihre Dateien organisieren kann. Ein Verzeichnis ist für die nichtflüchtigen Dateien Ihrer App vorgesehen und ein anderes enthält die Cache-Dateien Ihrer App. Ihre App benötigt keine Systemberechtigungen, um Dateien in diesen Verzeichnissen zu lesen und zu schreiben.

Andere Apps können nicht auf Dateien zugreifen, die im internen Speicher gespeichert sind. Daher ist der interne Speicher ein guter Ort für App-Daten, auf die andere Apps nicht zugreifen sollten.

Beachten Sie jedoch, dass diese Verzeichnisse in der Regel klein sind. Bevor Ihre App app-spezifische Dateien in den internen Speicher schreibt, sollte sie den kostenlosen Speicherplatz auf dem Gerät abfragen.

Auf nichtflüchtige Dateien zugreifen

Die normalen, nichtflüchtigen Dateien Ihrer App befinden sich in einem Verzeichnis, auf das Sie mit der filesDir Eigenschaft eines Kontextobjekts zugreifen können. Das Framework bietet mehrere Methoden, mit denen Sie auf Dateien in diesem Verzeichnis zugreifen und sie dort speichern können.

Auf Dateien zugreifen und sie speichern

Sie können die File API verwenden, um auf Dateien zuzugreifen und sie zu speichern.

Um die Leistung Ihrer App aufrechtzuerhalten, sollten Sie dieselbe Datei nicht mehrmals öffnen und schließen.

Das folgende Code-Snippet zeigt, wie Sie die File API verwenden:

val file = File(context.filesDir, filename)

File file = new File(context.getFilesDir(), filename);

Datei mit einem Stream speichern

Alternativ zur Verwendung der File API können Sie openFileOutput() aufrufen, um einen FileOutputStream abzurufen, der in eine Datei im Verzeichnis filesDir schreibt.

Das folgende Code-Snippet zeigt, wie Sie Text in eine Datei schreiben:

val filename = "myfile"
val fileContents = "Hello world!"
context.openFileOutput(filename, Context.MODE_PRIVATE).use {
        it.write(fileContents.toByteArray())
}

String filename = "myfile";
String fileContents = "Hello world!";
try (FileOutputStream fos = context.openFileOutput(filename, Context.MODE_PRIVATE)) {
    fos.write(fileContents.toByteArray());
}

Wenn Sie anderen Apps Zugriff auf Dateien gewähren möchten, die in diesem Verzeichnis im internen Speicher gespeichert sind, verwenden Sie einen FileProvider mit dem FLAG_GRANT_READ_URI_PERMISSION Attribut.

Auf eine Datei mit einem Stream zugreifen

Verwenden Sie openFileInput(), um eine Datei als Stream zu lesen:

context.openFileInput(filename).bufferedReader().useLines { lines ->
    lines.fold("") { some, text ->
        "$some\n$text"
    }
}

FileInputStream fis = context.openFileInput(filename);
InputStreamReader inputStreamReader =
        new InputStreamReader(fis, StandardCharsets.UTF_8);
StringBuilder stringBuilder = new StringBuilder();
try (BufferedReader reader = new BufferedReader(inputStreamReader)) {
    String line = reader.readLine();
    while (line != null) {
        stringBuilder.append(line).append('\n');
        line = reader.readLine();
    }
} catch (IOException e) {
    // Error occurred when opening raw file for reading.
} finally {
    String contents = stringBuilder.toString();
}

Liste der Dateien ansehen

Sie können ein Array mit den Namen aller Dateien im filesDir Verzeichnis abrufen, indem Sie fileList() aufrufen, wie in folgendem Code-Snippet gezeigt:

var files: Array<String> = context.fileList()

Array<String> files = context.fileList();

Unterverzeichnisse erstellen

Sie können auch Unterverzeichnisse erstellen oder ein inneres Verzeichnis öffnen, indem Sie getDir() in Kotlin-basiertem Code aufrufen oder in Java-basiertem Code das Stammverzeichnis und einen neuen Verzeichnisnamen an einen File Konstruktor übergeben:

context.getDir(dirName, Context.MODE_PRIVATE)

File directory = context.getFilesDir();
File file = new File(directory, filename);

Cache-Dateien erstellen

Wenn Sie vertrauliche Daten nur vorübergehend speichern müssen, sollten Sie das dafür vorgesehene Cache-Verzeichnis der App im internen Speicher verwenden, um die Daten zu speichern. Wie bei allen app-spezifischen Speichern werden die in diesem Verzeichnis gespeicherten Dateien entfernt, wenn der Nutzer Ihre App deinstalliert. Die Dateien in diesem Verzeichnis werden jedoch möglicherweise früher entfernt.

Rufen Sie File.createTempFile() auf, um eine Cache-Datei zu erstellen:

File.createTempFile(filename, null, context.cacheDir)

File.createTempFile(filename, null, context.getCacheDir());

Ihre App greift mit der cacheDir Eigenschaft eines Kontextobjekts und der File API auf eine Datei in diesem Verzeichnis zu:

val cacheFile = File(context.cacheDir, filename)

File cacheFile = new File(context.getCacheDir(), filename);

Cache-Dateien entfernen

Obwohl Android manchmal selbst Cache-Dateien löscht, sollten Sie sich nicht darauf verlassen, dass das System diese Dateien für Sie bereinigt. Sie sollten die Cache-Dateien Ihrer App immer im internen Speicher verwalten.

Verwenden Sie eine der folgenden Methoden, um eine Datei aus dem Cache-Verzeichnis im internen Speicher zu entfernen:

• Die delete() Methode für ein File Objekt das die Datei darstellt:

  Kotlin

  cacheFile.delete()

  Java

  cacheFile.delete();

• Die deleteFile() Methode des App-Kontexts, wobei Sie den Namen der Datei übergeben:

  Kotlin

  context.deleteFile(cacheFileName)

  Java

  context.deleteFile(cacheFileName);

Zugriff über den externen Speicher

Wenn der interne Speicher nicht genügend Platz für app-spezifische Dateien bietet, sollten Sie stattdessen den externen Speicher verwenden. Das System bietet Verzeichnisse im externen Speicher, in denen eine App Dateien organisieren kann, die für den Nutzer nur innerhalb Ihrer App von Nutzen sind. Ein Verzeichnis ist für die nichtflüchtigen Dateien Ihrer App vorgesehen und ein anderes enthält die Cache- Dateien Ihrer App.

Unter Android 4.4 (API-Level 19) oder höher muss Ihre App keine speicherbezogenen Berechtigungen anfordern, um auf app-spezifische Verzeichnisse im externen Speicher zuzugreifen. Die in diesen Verzeichnissen gespeicherten Dateien werden entfernt, wenn Ihre App deinstalliert wird.

// Checks if a volume containing external storage is available
// for read and write.
fun isExternalStorageWritable(): Boolean {
    return Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED
}

// Checks if a volume containing external storage is available to at least read.
fun isExternalStorageReadable(): Boolean {
     return Environment.getExternalStorageState() in
        setOf(Environment.MEDIA_MOUNTED, Environment.MEDIA_MOUNTED_READ_ONLY)
}

// Checks if a volume containing external storage is available
// for read and write.
private boolean isExternalStorageWritable() {
    return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
}

// Checks if a volume containing external storage is available to at least read.
private boolean isExternalStorageReadable() {
     return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) ||
            Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY);
}

adb shell sm set-virtual-disk true

val externalStorageVolumes: Array<out File> =
        ContextCompat.getExternalFilesDirs(applicationContext, null)
val primaryExternalStorage = externalStorageVolumes[0]

File[] externalStorageVolumes =
        ContextCompat.getExternalFilesDirs(getApplicationContext(), null);
File primaryExternalStorage = externalStorageVolumes[0];

val appSpecificExternalDir = File(context.getExternalFilesDir(null), filename)

File appSpecificExternalDir = new File(context.getExternalFilesDir(null), filename);

val externalCacheFile = File(context.externalCacheDir, filename)

File externalCacheFile = new File(context.getExternalCacheDir(), filename);

externalCacheFile.delete()

externalCacheFile.delete();

fun getAppSpecificAlbumStorageDir(context: Context, albumName: String): File? {
    // Get the pictures directory that's inside the app-specific directory on
    // external storage.
    val file = File(context.getExternalFilesDir(
            Environment.DIRECTORY_PICTURES), albumName)
    if (!file?.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created")
    }
    return file
}

@Nullable
File getAppSpecificAlbumStorageDir(Context context, String albumName) {
    // Get the pictures directory that's inside the app-specific directory on
    // external storage.
    File file = new File(context.getExternalFilesDir(
            Environment.DIRECTORY_PICTURES), albumName);
    if (file == null || !file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}

// App needs 10 MB within internal storage.
const val NUM_BYTES_NEEDED_FOR_MY_APP = 1024 * 1024 * 10L;

val storageManager = applicationContext.getSystemService<StorageManager>()!!
val appSpecificInternalDirUuid: UUID = storageManager.getUuidForPath(filesDir)
val availableBytes: Long =
        storageManager.getAllocatableBytes(appSpecificInternalDirUuid)
if (availableBytes >= NUM_BYTES_NEEDED_FOR_MY_APP) {
    storageManager.allocateBytes(
        appSpecificInternalDirUuid, NUM_BYTES_NEEDED_FOR_MY_APP)
} else {
    val storageIntent = Intent().apply {
        // To request that the user remove all app cache files instead, set
        // "action" to ACTION_CLEAR_APP_CACHE.
        action = ACTION_MANAGE_STORAGE
    }
}

// App needs 10 MB within internal storage.
private static final long NUM_BYTES_NEEDED_FOR_MY_APP = 1024 * 1024 * 10L;

StorageManager storageManager =
        getApplicationContext().getSystemService(StorageManager.class);
UUID appSpecificInternalDirUuid = storageManager.getUuidForPath(getFilesDir());
long availableBytes =
        storageManager.getAllocatableBytes(appSpecificInternalDirUuid);
if (availableBytes >= NUM_BYTES_NEEDED_FOR_MY_APP) {
    storageManager.allocateBytes(
            appSpecificInternalDirUuid, NUM_BYTES_NEEDED_FOR_MY_APP);
} else {
    // To request that the user remove all app cache files instead, set
    // "action" to ACTION_CLEAR_APP_CACHE.
    Intent storageIntent = new Intent();
    storageIntent.setAction(ACTION_MANAGE_STORAGE);
}

StorageStatsManager.getFreeBytes() / StorageStatsManager.getTotalBytes()