Accedere a documenti e altri file dallo spazio di archiviazione condiviso

Sui dispositivi con Android 4.4 (livello API 19) e versioni successive, la tua app può interagire con un fornitore di documenti, inclusi volumi di archiviazione esterni e archiviazione basata su cloud, utilizzando il framework Storage Access. Questo framework consente agli utenti di interagire con un selettore di sistema per scegliere un fornitore di documenti e selezionare documenti e altri file specifici da creare, aprire o modificare con la tua app.

Poiché l'utente è coinvolto nella selezione dei file o delle directory a cui può accedere la tua app, questo meccanismo non richiede autorizzazioni di sistema e il controllo e la privacy dell'utente vengono migliorati. Inoltre, questi file, che sono archiviati al di fuori di una directory specifica per l'app e al di fuori del media store, rimangono sul dispositivo dopo la disinstallazione dell'app.

L'utilizzo del framework prevede i seguenti passaggi:

1. Un'app richiama un'intent che contiene un'azione relativa allo spazio di archiviazione. Questa azione corrisponde a un caso d'uso specifico reso disponibile dal framework.
2. L'utente vede un selettore di sistema che gli consente di sfogliare un provider di documenti e scegliere una posizione o un documento in cui viene eseguita l'azione relativa allo spazio di archiviazione.
3. L'app ottiene l'accesso in lettura e scrittura a un URI che rappresenta la località o il documento scelto dall'utente. Utilizzando questo URI, l'app può eseguire operazioni sulla località scelta.

Nota: se la tua app accede a file multimediali, valuta la possibilità di utilizzare il selettore di foto, che offre un'interfaccia comoda per accedere a foto e video.

Per supportare l'accesso ai file multimediali sui dispositivi con Android 9 (livello API 28) o versioni precedenti, dichiara l'autorizzazione READ_EXTERNAL_STORAGE e imposta maxSdkVersion su 28.

Questa guida illustra i diversi casi d'uso supportati dal framework per lavorare con file e altri documenti. Spiega inoltre come eseguire operazioni sulla località selezionata dall'utente.

Casi d'uso per l'accesso a documenti e altri file

Storage Access Framework supporta i seguenti casi d'uso per accedere a file e altri documenti.

Creare un nuovo file

L'azione ACTION_CREATE_DOCUMENT dell'intent consente agli utenti di salvare un file in una posizione specifica.

Aprire un documento o un file

L'azione di intent ACTION_OPEN_DOCUMENT consente agli utenti di selezionare un documento o un file specifico da aprire.

Concedere l'accesso ai contenuti di una directory

L'azione di intent ACTION_OPEN_DOCUMENT_TREE disponibile su Android 5.0 (livello API 21) e versioni successive consente agli utenti di selezionare una directory specifica, concedendo alla tua app l'accesso a tutti i file e alle sottodirectory al suo interno.

Le sezioni seguenti forniscono indicazioni su come configurare ogni caso d'uso.

Creare un nuovo file

Utilizza l'azione di intent ACTION_CREATE_DOCUMENT per caricare il selettore file di sistema e consentire all'utente di scegliere una posizione in cui scrivere i contenuti di un file. Questa procedura è simile a quella utilizzata nelle finestre di dialogo "Salva come" di altri sistemi operativi.

Nota: ACTION_CREATE_DOCUMENT non può sovrascrivere un file esistente. Se l'app tenta di salvare un file con lo stesso nome, il sistema aggiunge un numero tra parentesi alla fine del nome del file.

Ad esempio, se la tua app tenta di salvare un file denominato confirmation.pdf in una directory in cui è già presente un file con questo nome, il sistema salva il nuovo file con il nome confirmation(1).pdf.

Quando configuri l'intent, specifica il nome e il tipo MIME del file e, facoltativamente, l'URI del file o della directory che il selettore di file deve mostrare al primo caricamento utilizzando l'elemento aggiuntivo dell'intent EXTRA_INITIAL_URI.

Il seguente snippet di codice mostra come creare e invocare l'intent per la creazione di un file:

Kotlin

// Request code for creating a PDF document.
const val CREATE_FILE = 1

private fun createFile(pickerInitialUri: Uri) {
    val intent = Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        type = "application/pdf"
        putExtra(Intent.EXTRA_TITLE, "invoice.pdf")

        // Optionally, specify a URI for the directory that should be opened in
        // the system file picker before your app creates the document.
        putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
    }
    startActivityForResult(intent, CREATE_FILE)
}

Java

// Request code for creating a PDF document.
private static final int CREATE_FILE = 1;

private void createFile(Uri pickerInitialUri) {
    Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.setType("application/pdf");
    intent.putExtra(Intent.EXTRA_TITLE, "invoice.pdf");

    // Optionally, specify a URI for the directory that should be opened in
    // the system file picker when your app creates the document.
    intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri);

    startActivityForResult(intent, CREATE_FILE);
}

Apri un file

La tua app potrebbe utilizzare i documenti come unità di archiviazione in cui gli utenti inseriscono i dati che potrebbero voler condividere con i colleghi o importare in altri documenti. Alcuni esempi includono un utente che apre un documento di produttività o un libro salvati come file EPUB.

In questi casi, consenti all'utente di scegliere il file da aprire richiamando l'intent ACTION_OPEN_DOCUMENT, che apre l'app di selezione dei file di sistema. Per mostrare solo i tipi di file supportati dalla tua app, specifica un tipo MIME. Inoltre, se vuoi, puoi specificare l'URI del file che il selettore di file deve mostrare al primo caricamento utilizzando l'intent extra EXTRA_INITIAL_URI.

Il seguente snippet di codice mostra come creare e invocare l'intent per l'apertura di un documento PDF:

Kotlin

// Request code for selecting a PDF document.
const val PICK_PDF_FILE = 2

fun openFile(pickerInitialUri: Uri) {
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        type = "application/pdf"

        // Optionally, specify a URI for the file that should appear in the
        // system file picker when it loads.
        putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
    }

    startActivityForResult(intent, PICK_PDF_FILE)
}

Java

// Request code for selecting a PDF document.
private static final int PICK_PDF_FILE = 2;

private void openFile(Uri pickerInitialUri) {
    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.setType("application/pdf");

    // Optionally, specify a URI for the file that should appear in the
    // system file picker when it loads.
    intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri);

    startActivityForResult(intent, PICK_PDF_FILE);
}

Restrizioni di accesso

Su Android 11 (livello API 30) e versioni successive, non puoi utilizzare l'azione di intent ACTION_OPEN_DOCUMENT per chiedere all'utente di selezionare singoli file dalle seguenti directory:

• La directory Android/data/ e tutte le sottodirectory.
• La directory Android/obb/ e tutte le sottodirectory.

Concedere l'accesso ai contenuti di una directory

Nota: l'azione intent descritta in questa sezione è disponibile su Android 5.0 (livello API 21) e versioni successive.

Le app di gestione dei file e di creazione di contenuti multimediali in genere gestiscono gruppi di file in una gerarchia di directory. Per fornire questa funzionalità nella tua app, utilizza l'azione di intent ACTION_OPEN_DOCUMENT_TREE, che consente all'utente di concedere l'accesso a un intero albero di directory, con alcune eccezioni a partire da Android 11 (livello API 30). L'app può quindi accedere a qualsiasi file nella directory selezionata e in qualsiasi sottodirectory.

Quando utilizzi ACTION_OPEN_DOCUMENT_TREE, la tua app ottiene l'accesso solo ai file nella directory selezionata dall'utente. Non hai accesso ai file di altre app che si trovano al di fuori di questa directory selezionata dall'utente. Questo accesso controllato dall'utente consente agli utenti di scegliere esattamente quali contenuti condividere con la tua app.

Facoltativamente, puoi specificare l'URI della directory che il selettore di file deve mostrare al primo caricamento utilizzando l'attributo extra dell'intent EXTRA_INITIAL_URI.

Il seguente snippet di codice mostra come creare e richiamare l'intent per l'apertura di una directory:

Kotlin

fun openDirectory(pickerInitialUri: Uri) {
    // Choose a directory using the system's file picker.
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {
        // Optionally, specify a URI for the directory that should be opened in
        // the system file picker when it loads.
        putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
    }

    startActivityForResult(intent, your-request-code)
}

Java

public void openDirectory(Uri uriToLoad) {
    // Choose a directory using the system's file picker.
    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);

    // Optionally, specify a URI for the directory that should be opened in
    // the system file picker when it loads.
    intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, uriToLoad);

    startActivityForResult(intent, your-request-code);
}

Attenzione: se esegui l'iterazione di un numero elevato di file all'interno della directory a cui viene eseguito l'accesso utilizzando ACTION_OPEN_DOCUMENT_TREE, le prestazioni dell'app potrebbero essere ridotte.

Restrizioni di accesso

Su Android 11 (livello API 30) e versioni successive, non puoi utilizzare l'azione intent ACTION_OPEN_DOCUMENT_TREE per richiedere l'accesso alle seguenti directory:

• La directory principale del volume della memoria interna.
• La home directory di ogni volume della scheda SD considerata attendibile dal produttore del dispositivo, indipendentemente dal fatto che la scheda sia emulata o rimovibile. Un volume affidabile è un volume a cui un'app può accedere correttamente la maggior parte del tempo.
• La directory Download.

Inoltre, su Android 11 (livello API 30) e versioni successive, non puoi utilizzare l'azione di intent ACTION_OPEN_DOCUMENT_TREE per richiedere all'utente di selezionare singoli file dalle seguenti directory:

• La directory Android/data/ e tutte le sottodirectory.
• La directory Android/obb/ e tutte le sottodirectory.

Esegui operazioni sulla località scelta

Dopo che l'utente ha selezionato un file o una directory utilizzando il selettore di file del sistema, puoi recuperare l'URI dell'elemento selezionato utilizzando il seguente codice in onActivityResult():

Kotlin

override fun onActivityResult(
        requestCode: Int, resultCode: Int, resultData: Intent?) {
    if (requestCode == your-request-code
            && resultCode == Activity.RESULT_OK) {
        // The result data contains a URI for the document or directory that
        // the user selected.
        resultData?.data?.also { uri ->
            // Perform operations on the document using its URI.
        }
    }
}

Java

@Override
public void onActivityResult(int requestCode, int resultCode,
        Intent resultData) {
    if (requestCode == your-request-code
            && resultCode == Activity.RESULT_OK) {
        // The result data contains a URI for the document or directory that
        // the user selected.
        Uri uri = null;
        if (resultData != null) {
            uri = resultData.getData();
            // Perform operations on the document using its URI.
        }
    }
}

Ottenendo un riferimento all'URI dell'elemento selezionato, la tua app può eseguire diverse operazioni sull'elemento. Ad esempio, puoi accedere ai metadati dell'elemento, modificarlo in situ ed eliminarlo.

Le seguenti sezioni mostrano come completare le azioni sui file selezionati dall'utente.

Determina le operazioni supportate da un fornitore

Fornitori di contenuti diversi consentono di eseguire operazioni diverse sui documenti, ad esempio copiarli o visualizzarne la miniatura. Per determinare quali operazioni supporta un determinato fornitore, controlla il valore di Document.COLUMN_FLAGS. L'interfaccia utente dell'app può quindi mostrare solo le opzioni supportate dal fornitore.

Mantieni le autorizzazioni

Quando la tua app apre un file per la lettura o la scrittura, il sistema concede all'app una concessione dell'autorizzazione URI per quel file, che dura fino al riavvio del dispositivo dell'utente. Supponiamo però che la tua app sia un'app di modifica di immagini e che tu voglia che gli utenti possano accedere alle 5 immagini che hanno modificato più di recente direttamente dalla tua app. Se il dispositivo dell'utente è stato riavviato, dovrai indirizzarlo nuovamente al selettore di sistema per trovare i file.

Per preservare l'accesso ai file dopo i riavvii del dispositivo e creare un'esperienza utente migliore, la tua app può "prendere" la concessione dell'autorizzazione URI permanente offerta dal sistema, come mostrato nel seguente snippet di codice:

Kotlin

val contentResolver = applicationContext.contentResolver

val takeFlags: Int = Intent.FLAG_GRANT_READ_URI_PERMISSION or
        Intent.FLAG_GRANT_WRITE_URI_PERMISSION
// Check for the freshest data.
contentResolver.takePersistableUriPermission(uri, takeFlags)

Java

final int takeFlags = intent.getFlags()
            & (Intent.FLAG_GRANT_READ_URI_PERMISSION
            | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
// Check for the freshest data.
getContentResolver().takePersistableUriPermission(uri, takeFlags);

Attenzione: anche dopo aver chiamato takePersistableUriPermission(), la tua app non conserva l'accesso all'URI se il documento associato viene spostato o eliminato. In questi casi, devi chiedere di nuovo l'autorizzazione per ottenere nuovamente l'accesso all'URI.

Esamina i metadati del documento

Quando hai l'URI di un documento, ottieni l'accesso ai relativi metadati. Questo snippet recupera i metadati di un documento specificato dall'URI e li registra:

Kotlin

val contentResolver = applicationContext.contentResolver

fun dumpImageMetaData(uri: Uri) {

    // The query, because it only applies to a single document, returns only
    // one row. There's no need to filter, sort, or select fields,
    // because we want all fields for one document.
    val cursor: Cursor? = contentResolver.query(
            uri, null, null, null, null, null)

    cursor?.use {
        // moveToFirst() returns false if the cursor has 0 rows. Very handy for
        // "if there's anything to look at, look at it" conditionals.
        if (it.moveToFirst()) {

            // Note it's called "Display Name". This is
            // provider-specific, and might not necessarily be the file name.
            val displayName: String =
                    it.getString(it.getColumnIndex(OpenableColumns.DISPLAY_NAME))
            Log.i(TAG, "Display Name: $displayName")

            val sizeIndex: Int = it.getColumnIndex(OpenableColumns.SIZE)
            // If the size is unknown, the value stored is null. But because an
            // int can't be null, the behavior is implementation-specific,
            // and unpredictable. So as
            // a rule, check if it's null before assigning to an int. This will
            // happen often: The storage API allows for remote files, whose
            // size might not be locally known.
            val size: String = if (!it.isNull(sizeIndex)) {
                // Technically the column stores an int, but cursor.getString()
                // will do the conversion automatically.
                it.getString(sizeIndex)
            } else {
                "Unknown"
            }
            Log.i(TAG, "Size: $size")
        }
    }
}

Java

public void dumpImageMetaData(Uri uri) {

    // The query, because it only applies to a single document, returns only
    // one row. There's no need to filter, sort, or select fields,
    // because we want all fields for one document.
    Cursor cursor = getActivity().getContentResolver()
            .query(uri, null, null, null, null, null);

    try {
        // moveToFirst() returns false if the cursor has 0 rows. Very handy for
        // "if there's anything to look at, look at it" conditionals.
        if (cursor != null && cursor.moveToFirst()) {

            // Note it's called "Display Name". This is
            // provider-specific, and might not necessarily be the file name.
            String displayName = cursor.getString(
                    cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
            Log.i(TAG, "Display Name: " + displayName);

            int sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
            // If the size is unknown, the value stored is null. But because an
            // int can't be null, the behavior is implementation-specific,
            // and unpredictable. So as
            // a rule, check if it's null before assigning to an int. This will
            // happen often: The storage API allows for remote files, whose
            // size might not be locally known.
            String size = null;
            if (!cursor.isNull(sizeIndex)) {
                // Technically the column stores an int, but cursor.getString()
                // will do the conversion automatically.
                size = cursor.getString(sizeIndex);
            } else {
                size = "Unknown";
            }
            Log.i(TAG, "Size: " + size);
        }
    } finally {
        cursor.close();
    }
}

Aprire un documento

Avendo un riferimento all'URI di un documento, puoi aprirlo per ulteriori operazioni di elaborazione. Questa sezione mostra esempi per l'apertura di un bitmap e di uno stream di input.

Bitmap

Il seguente snippet di codice mostra come aprire un Bitmap file in base al relativo URI:

Kotlin

val contentResolver = applicationContext.contentResolver

@Throws(IOException::class)
private fun getBitmapFromUri(uri: Uri): Bitmap {
    val parcelFileDescriptor: ParcelFileDescriptor =
            contentResolver.openFileDescriptor(uri, "r")
    val fileDescriptor: FileDescriptor = parcelFileDescriptor.fileDescriptor
    val image: Bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor)
    parcelFileDescriptor.close()
    return image
}

Java

private Bitmap getBitmapFromUri(Uri uri) throws IOException {
    ParcelFileDescriptor parcelFileDescriptor =
            getContentResolver().openFileDescriptor(uri, "r");
    FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
    Bitmap image = BitmapFactory.decodeFileDescriptor(fileDescriptor);
    parcelFileDescriptor.close();
    return image;
}

Nota: devi completare questa operazione in un thread di background, non nel thread dell'interfaccia utente.

Dopo aver aperto la bitmap, puoi visualizzarla in un ImageView.

Stream di input

Il seguente snippet di codice mostra come aprire un oggetto InputStream in base al relativo URI. In questo snippet, le righe del file vengono lette in una stringa:

Kotlin

val contentResolver = applicationContext.contentResolver

@Throws(IOException::class)
private fun readTextFromUri(uri: Uri): String {
    val stringBuilder = StringBuilder()
    contentResolver.openInputStream(uri)?.use { inputStream ->
        BufferedReader(InputStreamReader(inputStream)).use { reader ->
            var line: String? = reader.readLine()
            while (line != null) {
                stringBuilder.append(line)
                line = reader.readLine()
            }
        }
    }
    return stringBuilder.toString()
}

Java

private String readTextFromUri(Uri uri) throws IOException {
    StringBuilder stringBuilder = new StringBuilder();
    try (InputStream inputStream =
            getContentResolver().openInputStream(uri);
            BufferedReader reader = new BufferedReader(
            new InputStreamReader(Objects.requireNonNull(inputStream)))) {
        String line;
        while ((line = reader.readLine()) != null) {
            stringBuilder.append(line);
        }
    }
    return stringBuilder.toString();
}

Modificare un documento

Puoi utilizzare Storage Access Framework per modificare un documento di testo in situ.

Nota: il metodo della classe DocumentFile canWrite() non indica necessariamente che la tua app può modificare un documento. Questo accade perché questo metodo restituisce true se Document.COLUMN_FLAGS contiene uno dei valori FLAG_SUPPORTS_DELETE o FLAG_SUPPORTS_WRITE. Per determinare se la tua app può modificare un determinato documento, esegui una query direttamente sul valore di FLAG_SUPPORTS_WRITE.

Il seguente snippet di codice sovrascrive i contenuti del documento rappresentato dall'URI specificato:

Kotlin

val contentResolver = applicationContext.contentResolver

private fun alterDocument(uri: Uri) {
    try {
        contentResolver.openFileDescriptor(uri, "w")?.use {
            FileOutputStream(it.fileDescriptor).use {
                it.write(
                    ("Overwritten at ${System.currentTimeMillis()}\n")
                        .toByteArray()
                )
            }
        }
    } catch (e: FileNotFoundException) {
        e.printStackTrace()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

Java

private void alterDocument(Uri uri) {
    try {
        ParcelFileDescriptor pfd = getActivity().getContentResolver().
                openFileDescriptor(uri, "w");
        FileOutputStream fileOutputStream =
                new FileOutputStream(pfd.getFileDescriptor());
        fileOutputStream.write(("Overwritten at " + System.currentTimeMillis() +
                "\n").getBytes());
        // Let the document provider know you're done by closing the stream.
        fileOutputStream.close();
        pfd.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Eliminare un documento

Se disponi dell'URI di un documento e il Document.COLUMN_FLAGS del documento contiene SUPPORTS_DELETE, puoi eliminare il documento. Ad esempio:

Kotlin

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri)

Java

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri);

Recuperare un URI media equivalente

Il metodo getMediaUri() fornisce un URI del media store equivalente all'URI del fornitore di documenti fornito. I due URI fanno riferimento allo stesso elemento sottostante. Utilizzando l'URI del media store, puoi accedere più facilmente ai file multimediali dallo spazio di archiviazione condiviso.

Nota: questo metodo non concede nuove autorizzazioni. La tua app deve già disporre delle autorizzazioni necessarie per accedere a un determinato URI del provider di documenti, ad esempio aprendo il documento.

Il metodo getMediaUri() supporta gli URI ExternalStorageProvider. Su Android 12 (livello API 31) e versioni successive, il metodo supporta anche gli URI MediaDocumentsProvider.

Aprire un file virtuale

Su Android 7.0 (livello API 25) e versioni successive, la tua app può utilizzare i file virtuali messi a disposizione da Storage Access Framework. Anche se i file virtuali non hanno una rappresentazione binaria, la tua app può aprirne i contenuti forzandone la conversione in un tipo di file diverso o visualizzandoli utilizzando l'azione intent ACTION_VIEW.

Per aprire i file virtuali, l'app client deve includere una logica speciale per gestirli. Se vuoi ottenere una rappresentazione in byte del file, ad esempio per visualizzarne l'anteprima, devi richiedere un tipo MIME alternativo al fornitore di documenti.

Nota: poiché un'app non può aprire direttamente un file virtuale utilizzando il metodo openInputStream(), non utilizzare la categoria CATEGORY_OPENABLE quando crei l'intent contenente l'azione ACTION_OPEN_DOCUMENT o ACTION_OPEN_DOCUMENT_TREE.

Dopo che l'utente ha effettuato una selezione, utilizza l'URI nei dati dei risultati per determinare se il file è virtuale, come mostrato nel seguente snippet di codice:

Kotlin

private fun isVirtualFile(uri: Uri): Boolean {
    if (!DocumentsContract.isDocumentUri(this, uri)) {
        return false
    }

    val cursor: Cursor? = contentResolver.query(
            uri,
            arrayOf(DocumentsContract.Document.COLUMN_FLAGS),
            null,
            null,
            null
    )

    val flags: Int = cursor?.use {
        if (cursor.moveToFirst()) {
            cursor.getInt(0)
        } else {
            0
        }
    } ?: 0

    return flags and DocumentsContract.Document.FLAG_VIRTUAL_DOCUMENT != 0
}

Java

private boolean isVirtualFile(Uri uri) {
    if (!DocumentsContract.isDocumentUri(this, uri)) {
        return false;
    }

    Cursor cursor = getContentResolver().query(
        uri,
        new String[] { DocumentsContract.Document.COLUMN_FLAGS },
        null, null, null);

    int flags = 0;
    if (cursor.moveToFirst()) {
        flags = cursor.getInt(0);
    }
    cursor.close();

    return (flags & DocumentsContract.Document.FLAG_VIRTUAL_DOCUMENT) != 0;
}

Dopo aver verificato che il documento è un file virtuale, puoi forzare il file in un tipo MIME alternativo, ad esempio "image/png". Il seguente snippet di codice mostra come verificare se un file virtuale può essere rappresentato come immagine e, in caso affermativo, recupera uno stream di input dal file virtuale:

Kotlin

@Throws(IOException::class)
private fun getInputStreamForVirtualFile(
        uri: Uri, mimeTypeFilter: String): InputStream {

    val openableMimeTypes: Array<String>? =
            contentResolver.getStreamTypes(uri, mimeTypeFilter)

    return if (openableMimeTypes?.isNotEmpty() == true) {
        contentResolver
                .openTypedAssetFileDescriptor(uri, openableMimeTypes[0], null)
                .createInputStream()
    } else {
        throw FileNotFoundException()
    }
}

Java

private InputStream getInputStreamForVirtualFile(Uri uri, String mimeTypeFilter)
    throws IOException {

    ContentResolver resolver = getContentResolver();

    String[] openableMimeTypes = resolver.getStreamTypes(uri, mimeTypeFilter);

    if (openableMimeTypes == null ||
        openableMimeTypes.length < 1) {
        throw new FileNotFoundException();
    }

    return resolver
        .openTypedAssetFileDescriptor(uri, openableMimeTypes[0], null)
        .createInputStream();
}

Risorse aggiuntive

Per scoprire di più su come archiviare e accedere a documenti e altri file, consulta le seguenti risorse.

Campioni

• ActionOpenDocument, disponibile su GitHub.
• ActionOpenDocumentTree, disponibile su GitHub.

Video

• Preparazione allo spazio di archiviazione limitato (Android Dev Summit '19)