Auf App-spezifische Dateien zugreifen

In vielen Fällen erstellt Ihre Anwendung Dateien, auf die andere Anwendungen nicht zugreifen müssen oder auf die nicht zugreifen sollten. Das System bietet die folgenden Speicherorte zum Speichern solcher app-spezifischer Dateien:

• Interne Speicherverzeichnisse: Diese Verzeichnisse enthalten sowohl einen dedizierten Speicherort zum Speichern von nichtflüchtigen Dateien als auch einen weiteren Speicherort zum Speichern von Cache-Daten. Das System verhindert, dass andere Apps auf diese Standorte zugreifen. Unter Android 10 (API-Level 29) und höher werden diese Standorte verschlüsselt. Aufgrund dieser Eigenschaften eignen sich diese Speicherorte gut zum Speichern sensibler Daten, auf die nur Ihre App selbst zugreifen kann.

• Externe Speicherverzeichnisse: Diese Verzeichnisse enthalten sowohl einen dedizierten Speicherort zum Speichern von nichtflüchtigen Dateien als auch einen weiteren Speicherort zum Speichern von Cache-Daten. Es ist zwar möglich, dass eine andere Anwendung auf diese Verzeichnisse zugreifen kann, wenn diese Anwendung die entsprechenden Berechtigungen hat. Die in diesen Verzeichnissen gespeicherten Dateien sind jedoch nur für die Verwendung durch Ihre Anwendung gedacht. Wenn Sie speziell Dateien erstellen möchten, auf die andere Anwendungen zugreifen können sollen, sollte Ihre Anwendung diese Dateien stattdessen im freigegebenen Speicher des externen Speichers speichern.

Wenn der Nutzer Ihre App deinstalliert, werden die im App-spezifischen Speicher gespeicherten Dateien entfernt. Aus diesem Grund sollten Sie diesen Speicher nicht verwenden, um etwas zu speichern, das der Nutzer voraussichtlich unabhängig von Ihrer App aufbewahrt. Wenn Nutzer beispielsweise in Ihrer App Fotos aufnehmen können, erwarten sie, dass sie auch nach der Deinstallation der App auf diese Fotos zugreifen können. Sie sollten daher stattdessen freigegebenen Speicher verwenden, um diese Dateitypen in der entsprechenden Mediensammlung zu speichern.

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

Zugriff von internem Speicher

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

Andere Apps können nicht auf Dateien im internen Speicher zugreifen. Dies macht den internen Speicher zu einem guten Ort für App-Daten, auf die andere Apps nicht zugreifen sollten.

Denken Sie jedoch daran, dass diese Verzeichnisse in der Regel klein sind. Bevor appspezifische Dateien in den internen Speicher geschrieben werden, sollte die Anwendung den freien Speicherplatz auf dem Gerät abfragen.

Auf nichtflüchtige Dateien zugreifen

Die gewöhnlichen, nichtflüchtigen Dateien Ihrer Anwendung befinden sich in einem Verzeichnis, auf das Sie mit dem Attribut filesDir eines Kontextobjekts zugreifen können. Das Framework bietet mehrere Methoden, mit denen Sie auf Dateien in diesem Verzeichnis zugreifen und diese speichern können.

Auf Dateien zugreifen und sie speichern

Mit der File API können Sie auf Dateien zugreifen und diese speichern.

Öffnen und schließen Sie dieselbe Datei nicht mehrmals, um die Leistung Ihrer Anwendung aufrechtzuerhalten.

Das folgende Code-Snippet zeigt, wie die File API verwendet wird:

val file = File(context.filesDir, filename)

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

Dateien mithilfe eines Streams speichern

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

Das folgende Code-Snippet zeigt, wie Text in eine Datei geschrieben wird:

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 Anwendungen den Zugriff auf Dateien erlauben möchten, die in diesem Verzeichnis innerhalb des internen Speichers gespeichert sind, verwenden Sie FileProvider mit dem Attribut FLAG_GRANT_READ_URI_PERMISSION.

Über einen Stream auf eine Datei 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();
}

Dateiliste ansehen

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

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

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

Verschachtelte Verzeichnisse erstellen

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

context.getDir(dirName, Context.MODE_PRIVATE)

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

Cache-Dateien erstellen

Wenn Sie sensible Daten nur vorübergehend speichern müssen, sollten Sie zum Speichern der Daten das für die Anwendung festgelegte Cache-Verzeichnis innerhalb des internen Speichers verwenden. Wie bei allen App-spezifischen Speichern werden die in diesem Verzeichnis gespeicherten Dateien entfernt, wenn der Nutzer die App deinstalliert. Die Dateien in diesem Verzeichnis werden jedoch möglicherweise früher entfernt.

Rufen Sie zum Erstellen einer im Cache gespeicherten Datei File.createTempFile() auf:

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

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

Ihre Anwendung greift mit dem Attribut cacheDir 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

Auch wenn Android Cache-Dateien manchmal selbst löscht, sollten Sie sich nicht darauf verlassen, dass das System diese Dateien bereinigt. Sie sollten die Cache-Dateien Ihrer Anwendung immer im internen Speicher belassen.

Mit einer der folgenden Methoden können Sie eine Datei aus dem Cache-Verzeichnis im internen Speicher entfernen:

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

  Kotlin

  cacheFile.delete()
  

  Java

  cacheFile.delete();
  

• Mit der Methode deleteFile() des Anwendungskontexts wird der Name der Datei übergeben:

  Kotlin

  context.deleteFile(cacheFileName)
  

  Java

  context.deleteFile(cacheFileName);
  

Zugriff von externem Speicher

Wenn der interne Speicher nicht genügend Speicherplatz zum Speichern anwendungsspezifischer Dateien bietet, sollten Sie stattdessen einen externen Speicher verwenden. Das System stellt Verzeichnisse innerhalb des externen Speichers bereit, in denen eine Anwendung Dateien organisieren kann, die dem Nutzer nur innerhalb Ihrer Anwendung einen Mehrwert bieten. Ein Verzeichnis ist für die nichtflüchtigen Dateien Ihrer Anwendung vorgesehen und ein anderes enthält die im Cache gespeicherten Dateien Ihrer Anwendung.

Unter Android 4.4 (API-Level 19) oder höher muss deine App keine speicherbezogenen Berechtigungen anfordern, um auf appspezifische Verzeichnisse innerhalb des externen Speichers zuzugreifen. Die in diesen Verzeichnissen gespeicherten Dateien werden entfernt, wenn die Anwendung deinstalliert wird.

Auf Geräten mit Android 9 (API-Level 28) oder niedriger kann deine App auf die App-spezifischen Dateien anderer Apps zugreifen, sofern deine App die entsprechenden Speicherberechtigungen hat. Damit Nutzer mehr Kontrolle über ihre Dateien haben und die Datei nicht überladen wird, erhalten Apps für Android 10 (API-Level 29) und höher standardmäßig eingeschränkten Zugriff auf externen Speicher oder begrenzten Speicher. Wenn begrenzter Speicher aktiviert ist, können Anwendungen nicht auf die anwendungsspezifischen Verzeichnisse zugreifen, die zu anderen Anwendungen gehören.

Prüfen, ob Speicherplatz verfügbar ist

Da sich der externe Speicher auf einem physischen Volume befindet, das der Nutzer möglicherweise entfernen kann, sollten Sie prüfen, ob das Volume zugänglich ist, bevor Sie versuchen, anwendungsspezifische Daten aus dem externen Speicher zu lesen oder anwendungsspezifische Daten darauf zu schreiben.

Sie können den Status des Volumes durch Aufrufen von Environment.getExternalStorageState() abfragen. Wenn der zurückgegebene Status MEDIA_MOUNTED lautet, können Sie anwendungsspezifische Dateien im externen Speicher lesen und schreiben. Wenn der Wert MEDIA_MOUNTED_READ_ONLY lautet, können Sie diese Dateien nur lesen.

Die folgenden Methoden sind beispielsweise nützlich, um die Speicherverfügbarkeit zu ermitteln:

// 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);
}

Verwenden Sie auf Geräten ohne Wechseldatenträger den folgenden Befehl, um ein virtuelles Volume zum Testen der Verfügbarkeitslogik für externen Speicher zu aktivieren:

adb shell sm set-virtual-disk true

Physischen Speicherort auswählen

Manchmal bietet ein Gerät, das eine Partition seines internen Speichers als externen Speicher zuordnet, auch einen SD-Karten-Slot. Das bedeutet, dass das Gerät über mehrere physische Volumes verfügt, die externen Speicher enthalten können. Daher müssen Sie auswählen, welches für Ihren anwendungsspezifischen Speicher verwendet werden soll.

Rufen Sie ContextCompat.getExternalFilesDirs() auf, um auf die verschiedenen Standorte zuzugreifen. Wie im Code-Snippet gezeigt, wird das erste Element im zurückgegebenen Array als primäres externes Speicher-Volume betrachtet. Verwenden Sie dieses Volume, es sei denn, es ist voll oder nicht verfügbar.

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

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

Auf nichtflüchtige Dateien zugreifen

Rufen Sie getExternalFilesDir() auf, um aus dem externen Speicher auf anwendungsspezifische Dateien zuzugreifen.

Öffnen und schließen Sie dieselbe Datei nicht mehrmals, um die Leistung Ihrer Anwendung aufrechtzuerhalten.

Das folgende Code-Snippet zeigt, wie getExternalFilesDir() aufgerufen wird:

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

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

Cache-Dateien erstellen

Wenn Sie dem Cache im externen Speicher eine anwendungsspezifische Datei hinzufügen möchten, rufen Sie einen Verweis auf externalCacheDir ab:

val externalCacheFile = File(context.externalCacheDir, filename)

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

Cache-Dateien entfernen

Wenn Sie eine Datei aus dem externen Cache-Verzeichnis entfernen möchten, verwenden Sie die Methode delete() für ein File-Objekt, das die Datei darstellt:

externalCacheFile.delete()

externalCacheFile.delete();

Medieninhalte

Wenn Ihre App mit Mediendateien arbeitet, die dem Nutzer nur innerhalb Ihrer App einen Mehrwert bieten, empfiehlt es sich, sie in anwendungsspezifischen Verzeichnissen innerhalb des externen Speichers zu speichern, wie im folgenden Code-Snippet gezeigt:

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;
}

Es ist wichtig, dass Sie Verzeichnisnamen verwenden, die von API-Konstanten wie DIRECTORY_PICTURES bereitgestellt werden. Diese Verzeichnisnamen stellen sicher, dass die Dateien vom System ordnungsgemäß behandelt werden. Wenn keiner der vordefinierten Unterverzeichnisnamen zu Ihren Dateien passt, können Sie stattdessen null in getExternalFilesDir() übergeben. Dadurch wird das anwendungsspezifische Stammverzeichnis innerhalb des externen Speichers zurückgegeben.

Freien Speicherplatz abfragen

Viele Nutzer haben nicht viel Speicherplatz auf ihren Geräten. Ihre Anwendung sollte daher Speicherplatz mit Bedacht belegen.

Wenn du vorab weißt, wie viele Daten du speicherst, kannst du durch Aufrufen von getAllocatableBytes() herausfinden, wie viel Speicherplatz das Gerät für deine App zur Verfügung stellen kann. Der Rückgabewert von getAllocatableBytes() ist möglicherweise größer als die aktuelle Menge an freiem Speicherplatz auf dem Gerät. Das liegt daran, dass das System Dateien identifiziert hat, die aus den Cache-Verzeichnissen anderer Apps entfernt werden können.

Wenn genügend Speicherplatz zum Speichern der App-Daten vorhanden ist, rufen Sie allocateBytes() auf. Andernfalls kann deine App den Nutzer auffordern, einige Dateien vom Gerät zu entfernen oder alle Cache-Dateien vom Gerät zu entfernen.

Das folgende Code-Snippet zeigt ein Beispiel dafür, wie deine App freien Speicherplatz auf dem Gerät abfragen kann:

// 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);
}

Aktivität zur Speicherverwaltung erstellen

Ihre App kann eine benutzerdefinierte Aktivität deklarieren und erstellen, die es dem Nutzer nach dem Start ermöglicht, die Daten zu verwalten, die Ihre App auf dem Gerät des Nutzers gespeichert hat. Diese benutzerdefinierte Aktivität vom Typ „Speicherplatz verwalten“ deklarieren Sie mit dem Attribut android:manageSpaceActivity in der Manifestdatei. Dateimanager-Apps können diese Aktivität aufrufen, auch wenn die Aktivität von Ihrer App nicht exportiert wird, also wenn android:exported in Ihrer Aktivität auf false gesetzt ist.

Nutzer bitten, einige Gerätedateien zu entfernen

Damit der Nutzer Dateien auf dem Gerät auswählen soll, die entfernt werden sollen, rufen Sie einen Intent auf, der die Aktion ACTION_MANAGE_STORAGE enthält. Mit diesem Intent wird dem Nutzer eine Aufforderung angezeigt. Bei Bedarf kann diese Aufforderung den freien Speicherplatz auf dem Gerät anzeigen. Verwenden Sie das Ergebnis der folgenden Berechnung, um diese nutzerfreundlichen Informationen anzuzeigen:

StorageStatsManager.getFreeBytes() / StorageStatsManager.getTotalBytes()

Nutzer bitten, alle Cache-Dateien zu entfernen

Alternativ können Sie den Nutzer bitten, die Cache-Dateien aus allen Apps auf dem Gerät zu löschen. Rufen Sie dazu einen Intent auf, der die Intent-Aktion ACTION_CLEAR_APP_CACHE enthält.

Zusätzliche Ressourcen

Weitere Informationen zum Speichern von Dateien im Gerätespeicher finden Sie in den folgenden Ressourcen.

Videos

• Vorbereitung auf begrenzten Speicher (Android Dev Summit '19)