Paylaşılan depolama alanındaki dokümanlara ve diğer dosyalara erişme

Android 4.4 (API düzeyi 19) ve sonraki sürümleri çalıştıran cihazlarda uygulamanız, Depolama Erişim Çerçevesi'ni kullanarak harici depolama birimleri ve bulut tabanlı depolama alanı da dahil olmak üzere bir belge sağlayıcıyla etkileşimde bulunabilir. Bu çerçeve, kullanıcıların bir sistem seçiciyle etkileşim kurarak doküman sağlayıcısı belirlemesini ve uygulamanızın oluşturması, açması veya değiştirmesi için belirli dokümanları ve diğer dosyaları seçmesini sağlar.

Uygulamanızın erişebileceği dosya veya dizinlerin seçiminde kullanıcı rol oynadığı için bu mekanizma herhangi bir sistem izni gerektirmez ve kullanıcı kontrolü ile gizliliği geliştirilir. Ayrıca, uygulamaya özel bir dizinin ve medya mağazasının dışında depolanan bu dosyalar, uygulamanızın yüklemesi kaldırıldıktan sonra cihazda kalır.

Çerçeveyi kullanmak için şu adımları izlemeniz gerekir:

1. Uygulama, depolama alanıyla ilgili işlem içeren bir intent çağırıyor. Bu işlem, çerçevenin sunduğu belirli bir kullanım alanına karşılık gelir.
2. Kullanıcı, doküman sağlayıcısına göz atmasına ve depolamayla ilgili işlemin gerçekleştirileceği konumu veya dokümanı seçmesine olanak tanıyan bir sistem seçici görür.
3. Uygulama, kullanıcının seçtiği konumu veya dokümanı temsil eden bir URI'ye okuma ve yazma erişimi elde eder. Uygulama, bu URI'yı kullanarak seçilen konumda işlemler gerçekleştirebilir.

Android 9 (API düzeyi 28) veya önceki sürümleri çalıştıran cihazlarda medya dosyasına erişimi desteklemek için READ_EXTERNAL_STORAGE iznini beyan edin ve maxSdkVersion değerini 28 olarak ayarlayın.

Bu kılavuzda, çerçevenin dosyalar ve diğer belgelerle çalışırken desteklediği farklı kullanım alanları açıklanmaktadır. Ayrıca, işlemlerin kullanıcı tarafından seçilen konumda nasıl gerçekleştirileceği de açıklanmaktadır.

Dokümanlara ve diğer dosyalara erişmek için kullanım alanları

Depolama Erişim Çerçevesi, dosyalara ve diğer dokümanlara erişim için aşağıdaki kullanım alanlarını destekler.

Yeni dosya oluşturma

ACTION_CREATE_DOCUMENT intent işlemi, kullanıcıların dosyaları belirli bir konuma kaydetmesine olanak tanır.

Doküman veya dosya açma

ACTION_OPEN_DOCUMENT intent işlemi, kullanıcıların açılacak belirli bir dokümanı veya dosyayı seçmesine olanak tanır.

Dizin içeriğine erişim izni verme

Android 5.0 (API düzeyi 21) ve sonraki sürümlerde kullanılabilen ACTION_OPEN_DOCUMENT_TREE intent işlemi, kullanıcıların belirli bir dizini seçmesine olanak tanıyarak uygulamanızın bu dizindeki tüm dosyalara ve alt dizinlere erişmesine izin verir.

Aşağıdaki bölümlerde, her bir kullanım alanının nasıl yapılandırılacağına ilişkin yol gösterici bilgiler sağlanmaktadır.

Yeni dosya oluşturma

Sistem dosya seçiciyi yüklemek ve kullanıcının dosya içeriğini yazacağı bir konum seçmesine izin vermek için ACTION_CREATE_DOCUMENT intent işlemini kullanın. Bu işlem, diğer işletim sistemlerinin kullandığı "farklı kaydet" iletişim kutularında kullanılan sürece benzer.

Amacı yapılandırırken dosyanın adını ve MIME türünü belirtin. İsterseniz, EXTRA_INITIAL_URI intent ekstrasını kullanarak dosya seçicinin ilk yüklediğinde görüntülemesi gereken dosya veya dizinin URI'sını da belirtebilirsiniz.

Aşağıdaki kod snippet'i, dosya oluşturma amacının nasıl oluşturulacağını ve çağrılacağını gösterir:

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

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

Dosya aç

Uygulamanız, kullanıcıların eşleriyle paylaşmak veya başka dokümanlara aktarmak isteyebilecekleri verileri girdikleri depolama birimi olarak dokümanları kullanabilir. Bir kullanıcının bir verimlilik dokümanını veya EPUB dosyası olarak kaydedilen bir kitabı açmasını, bu birkaç örnek verelim.

Bu gibi durumlarda, sistemin dosya seçici uygulamasını açan ACTION_OPEN_DOCUMENT amacını çağırarak kullanıcının açılacak dosyayı seçmesine izin verin. Yalnızca uygulamanızın desteklediği dosya türlerini göstermek için bir MIME türü belirtin. Ayrıca, isteğe bağlı olarak, dosya seçicinin ilk yüklendiğinde görüntülemesi gereken dosyanın URI'sini, EXTRA_INITIAL_URI intent ekstrasını kullanarak belirtebilirsiniz.

Aşağıdaki kod snippet'inde, bir PDF dokümanını açma amacının nasıl oluşturulacağı ve çağrılacağı gösterilmektedir:

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

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

Erişim kısıtlamaları

Android 11 (API düzeyi 30) ve sonraki sürümlerde kullanıcının aşağıdaki dizinlerden ayrı dosyalar seçmesini istemek için ACTION_OPEN_DOCUMENT intent işlemini kullanamazsınız:

• Android/data/ dizini ve tüm alt dizinler.
• Android/obb/ dizini ve tüm alt dizinler.

Dizin içeriğine erişim izni verme

Dosya yönetimi ve medya oluşturma uygulamaları, genellikle dosya gruplarını bir dizin hiyerarşisinde yönetir. Uygulamanızda bu özelliği sağlamak için ACTION_OPEN_DOCUMENT_TREE intent işlemini kullanın. Bu işlem, Android 11'den (API düzeyi 30) itibaren kullanıcının tüm dizin ağacına erişim izni vermesine olanak tanır. Böylece uygulamanız, seçilen dizindeki ve bunun alt dizinlerindeki herhangi bir dosyaya erişebilir.

ACTION_OPEN_DOCUMENT_TREE kullanılırken uygulamanız yalnızca kullanıcının seçtiği dizindeki dosyalara erişim elde eder. Kullanıcı tarafından seçilen bu dizinin dışında bulunan diğer uygulama dosyalarına erişiminiz yok. Kullanıcı tarafından kontrol edilen bu erişim, kullanıcıların tam olarak uygulamanızla paylaşmak istedikleri içeriği seçmelerine olanak tanır.

İsteğe bağlı olarak, dosya seçicinin ilk yüklendiğinde görüntülemesi gereken dizinin URI'sını, EXTRA_INITIAL_URI intent ekstrasını kullanarak belirtebilirsiniz.

Aşağıdaki kod snippet'i, bir dizini açma amacının nasıl oluşturulacağını ve çağrılacağını gösterir:

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

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

Erişim kısıtlamaları

Android 11 (API düzeyi 30) ve sonraki sürümlerde aşağıdaki dizinlere erişim isteğinde bulunmak için ACTION_OPEN_DOCUMENT_TREE intent işlemini kullanamazsınız:

• Dahili depolama biriminin kök dizini.
• Kartın emülasyon veya çıkarılabilir olmasına bakılmaksızın, cihaz üreticisinin güvenilir olarak kabul ettiği her bir SD kart biriminin kök dizini. Bir uygulamanın çoğu zaman başarılı bir şekilde erişebildiği hacim, güvenilir birimdir.
• Download dizini.

Ayrıca Android 11 (API düzeyi 30) ve sonraki sürümlerde kullanıcının aşağıdaki dizinlerden tek tek dosyaları seçmesini istemek için ACTION_OPEN_DOCUMENT_TREE intent işlemini kullanamazsınız:

• Android/data/ dizini ve tüm alt dizinler.
• Android/obb/ dizini ve tüm alt dizinler.

Seçilen konumda işlemler gerçekleştirin

Kullanıcı, sistemin dosya seçiciyi kullanarak bir dosya veya dizin seçtikten sonra, onActivityResult() içindeki şu kodu kullanarak seçilen öğenin URI'sini alabilirsiniz:

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

@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.
        }
    }
}

Uygulamanız, seçilen öğenin URI'sına başvurarak öğe üzerinde çeşitli işlemler gerçekleştirebilir. Örneğin, öğenin meta verilerine erişebilir, öğeyi yerinde düzenleyebilir ve öğeyi silebilirsiniz.

Aşağıdaki bölümlerde, kullanıcının seçtiği dosyalardaki işlemlerin nasıl tamamlanacağı gösterilmektedir.

Bir sağlayıcının desteklediği işlemleri belirleme

Farklı içerik sağlayıcılar, belgeler üzerinde farklı işlemlerin (ör. belgeyi kopyalama veya belgenin küçük resmini görüntüleme) gerçekleştirilmesine izin verir. Belirli bir sağlayıcının hangi işlemleri desteklediğini belirlemek için Document.COLUMN_FLAGS değerini kontrol edin. Bu işlemin ardından uygulamanızın kullanıcı arayüzü yalnızca sağlayıcının desteklediği seçenekleri gösterebilir.

İzinleri sürdür

Uygulamanız okuma veya yazma amacıyla bir dosya açtığında sistem, uygulamanıza bu dosya için bir URI izni verir. Bu izin kullanıcının cihazı yeniden başlatılana kadar geçerli olur. Bununla birlikte, uygulamanızın bir resim düzenleme uygulaması olduğunu ve kullanıcıların en son düzenledikleri 5 resme doğrudan uygulamanızdan erişebilmesini istediğinizi varsayalım. Kullanıcının cihazı yeniden başlatılırsa, dosyaları bulmak için kullanıcıyı sistem seçiciye geri göndermeniz gerekir.

Uygulamanız, yeniden başlatma sırasında dosyalara erişimi korumak ve daha iyi bir kullanıcı deneyimi sunmak için sistemin sunduğu kalıcı URI izni iznini aşağıdaki kod snippet'inde gösterildiği gibi "alabilir":

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)

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

Belge meta verilerini inceleme

Bir dokümanın URI'sına sahip olduğunuzda, dokümanın meta verilerine erişim sağlarsınız. Bu snippet, URI tarafından belirtilen bir belgenin meta verilerini alır ve günlüğe kaydeder:

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")
        }
    }
}

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

Doküman açma

Bir dokümanın URI'sına başvurarak, daha ayrıntılı işlenmek üzere dokümanı açabilirsiniz. Bu bölümde bit eşlem ve giriş akışı açma örnekleri gösterilmektedir.

Bit eşlem

Aşağıdaki kod snippet'i, URI'si verildiğinde bir Bitmap dosyasının nasıl açılacağını göstermektedir:

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
}

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

Bit eşlemi açtıktan sonra bir ImageView içinde görüntüleyebilirsiniz.

Akış girişi

Aşağıdaki kod snippet'i, URI'sine göre bir ListingStream nesnesinin nasıl açılacağını gösterir. Bu snippet'te, dosya satırları bir dizeye okunmaktadır:

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()
}

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

Doküman düzenleme

Yerinde metin dokümanını düzenlemek için Depolama Erişim Çerçevesi'ni kullanabilirsiniz.

Aşağıdaki kod snippet'i, belirtilen URI ile temsil edilen belge içeriğinin üzerine yazar:

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()
    }
}

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

Doküman silme

Bir belgenin URI'sına sahipseniz ve belgenin Document.COLUMN_FLAGS öğesi SUPPORTS_DELETE içeriyorsa dokümanı silebilirsiniz. Örnek:

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri)

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri);

Eşdeğer bir medya URI'si al

getMediaUri() yöntemi, belirtilen belge sağlayıcısı URI'sine eşdeğer bir medya deposu URI'si sağlar. 2 URI, aynı temel öğeye işaret eder. Medya deposu URI'sini kullanarak paylaşılan depolama alanından medya dosyalarına daha kolay şekilde erişebilirsiniz.

getMediaUri() yöntemi ExternalStorageProvider URI'ları destekler. Bu yöntem, Android 12 (API düzeyi 31) ve sonraki sürümlerde MediaDocumentsProvider URI'lerini de destekler.

Sanal dosya açın

Android 7.0 (API düzeyi 25) ve sonraki sürümlerde uygulamanız Depolama Erişim Çerçevesi'nin kullanıma sunduğu sanal dosyalardan yararlanabilir. Sanal dosyalar ikili program içermese de, uygulamanız bu dosyaları farklı bir dosya türüne zorlayarak veya ACTION_VIEW intent işlemini kullanarak dosyaları görüntüleyerek içeriklerini açabilir.

Sanal dosyaları açmak için istemci uygulamanızın bunları işlemek üzere özel bir mantık içermesi gerekir. Örneğin, dosyayı önizlemek için, dosyanın bayt gösterimini almak istiyorsanız doküman sağlayıcısından alternatif bir MIME türü istemeniz gerekir.

Kullanıcı bir seçim yaptıktan sonra, aşağıdaki kod snippet'inde gösterildiği gibi dosyanın sanal olup olmadığını belirlemek için sonuç verilerindeki URI'yi kullanın:

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
}

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

Dokümanın sanal bir dosya olduğunu doğruladıktan sonra, dosyayı "image/png" gibi alternatif bir MIME türüne zorlayabilirsiniz. Aşağıdaki kod snippet'i, bir sanal dosyanın resim olarak temsil edilip edilemeyeceğini ve bu şekilde temsil edilebiliyorsa sanal dosyadan giriş akışı alıp almadığının nasıl kontrol edileceğini gösterir:

@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()
    }
}

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

Ek kaynaklar

Belgeleri ve diğer dosyaları depolama ve bunlara erişme hakkında daha fazla bilgi için aşağıdaki kaynaklara başvurun.

Numuneler

• ActionOpenDocument, GitHub'da mevcuttur.
• ActionOpenDocumentTree, GitHub'da mevcut.

Videolar

• Scoped Storage (Kapsamlı Depolama Alanı) için hazırlanma (Android Dev Summit) 2019