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ı dahil olmak üzere bir doküman sağlayıcı ile etkileşim kurabilir. Bu çerçeve, kullanıcıların bir doküman sağlayıcı seçmek ve uygulamanızın oluşturması, açması veya değiştirmesi için belirli dokümanları ve diğer dosyaları seçmek üzere sisteme ait seçim aracıyla etkileşim kurmasına olanak tanır.

Uygulamanızın erişebileceği dosyaları veya dizinleri seçme işlemine kullanıcı dahil olduğu için bu mekanizma herhangi bir sistem izni gerektirmez. Ayrıca kullanıcı kontrolü ve gizlilik de artırılır. Ayrıca, uygulamaya özel bir dizinin ve medya mağazasının dışında depolanan bu dosyalar, uygulamanız kaldırıldıktan sonra cihazda kalır.

Çerçeveyi kullanmak aşağıdaki adımları içerir:

  1. Uygulama, depolama alanıyla ilgili bir işlem içeren intent'i çağırır. 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ıya göz atmasına ve depolamayla ilgili işlemin gerçekleştiği konumu veya dokümanı seçmesine olanak tanıyan sisteme ait seçim aracını 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'yi kullanarak seçilen konumda işlemler gerçekleştirebilir.

Android 9 (API düzeyi 28) veya önceki sürümlerin yüklü olduğu cihazlarda medya dosyası erişimini desteklemek için READ_EXTERNAL_STORAGE iznini beyan edin ve maxSdkVersion değerini 28 olarak ayarlayın.

Bu kılavuzda, çerçeve tarafından desteklenen farklı kullanım alanları açıklanmaktadır. Ayrıca, kullanıcı tarafından seçilen konumda işlemlerin nasıl gerçekleştirileceğini de açıklar.

Belgelere ve diğer dosyalara erişimle ilgili kullanım alanları

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

Yeni dosya oluşturma
ACTION_CREATE_DOCUMENT intent işlemi, kullanıcıların bir dosyayı belirli bir konuma kaydetmesine olanak tanır.
Doküman veya dosya açma
ACTION_OPEN_DOCUMENT intent işlemi, kullanıcıların açmak için belirli bir doküman veya dosya seçmesine olanak tanır.
Bir dizinin 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ıza bu dizindeki tüm dosyalara ve alt dizinlere erişim izni verir.

Aşağıdaki bölümlerde, her kullanım alanının nasıl yapılandırılacağıyla ilgili bilgiler verilmektedir.

Yeni dosya oluşturma

Sistem dosya seçicisini yüklemek ve kullanıcının bir dosyanın içeriğini yazacağı konumu 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 işleme benzer.

Not: ACTION_CREATE_DOCUMENT, mevcut bir dosyanın üzerine yazamaz. Uygulamanız aynı ada sahip bir dosyayı kaydetmeye çalışırsa sistem, dosya adının sonuna parantez içinde bir sayı ekler.

Örneğin, uygulamanız confirmation.pdf adlı bir dosyayı, aynı ada sahip bir dosyanın bulunduğu dizine kaydetmeye çalışırsa sistem yeni dosyayı confirmation(1).pdf adıyla kaydeder.

Intent'i yapılandırırken dosyanın adını ve MIME türünü belirtin. İsteğe bağlı olarak, dosya seçicinin ilk yüklendiğinde göstermesi gereken dosya veya dizinin URI'sini EXTRA_INITIAL_URI intent ek bilgisini kullanarak belirtin.

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

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

Dosya açma

Uygulamanız, kullanıcıların diğer kullanıcılarla paylaşmak veya başka dokümanlara aktarmak isteyebileceği verileri girdiği depolama birimi olarak dokümanları kullanabilir. Kullanıcının bir üretkenlik dokümanını veya EPUB dosyası olarak kaydedilmiş bir kitabı açması buna örnek verilebilir.

Bu gibi durumlarda, sistemin dosya seçici uygulamasını açan ACTION_OPEN_DOCUMENT intent'ini ç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, dosya seçicinin ilk yüklendiğinde görüntülemesi gereken dosyanın URI'sini EXTRA_INITIAL_URI intent extra'yı kullanarak isteğe bağlı olarak belirtebilirsiniz.

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

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

Erişim kısıtlamaları

Android 11 (API düzeyi 30) ve sonraki sürümlerde, kullanıcının aşağıdaki dizinlerden tek tek dosya 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.

Bir dizinin içeriğine erişim izni verme

Dosya yönetimi ve medya oluşturma uygulamaları genellikle bir dizin hiyerarşisindeki dosya gruplarını yönetir. Bu özelliği uygulamanızda sunmak için ACTION_OPEN_DOCUMENT_TREE intent işlemini kullanın. Bu işlem, kullanıcının tüm dizin ağacına erişim izni vermesini sağlar. Android 11'den (API düzeyi 30) itibaren bazı istisnalar geçerlidir. Uygulamanız daha sonra seçilen dizindeki ve alt dizinlerindeki tüm dosyalara erişebilir.

ACTION_OPEN_DOCUMENT_TREE kullanıldığında uygulamanız yalnızca kullanıcının seçtiği dizindeki dosyalara erişebilir. Kullanıcı tarafından seçilen bu dizinin dışında bulunan diğer uygulamaların dosyalarına erişemezsiniz. Kullanıcı tarafından kontrol edilen bu erişim, kullanıcıların uygulamanızla paylaşmak istedikleri içerikleri tam olarak seçmelerine olanak tanır.

İsteğe bağlı olarak, dosya seçicinin ilk yüklendiğinde göstermesi gereken dizinin URI'sini EXTRA_INITIAL_URI intent extra'yı kullanarak belirtebilirsiniz.

Aşağıdaki kod snippet'inde, dizin açma intent'inin nasıl oluşturulacağı ve çağrılacağı gösterilmektedir:

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

Erişim kısıtlamaları

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

  • Dahili depolama biriminin kök dizini.
  • Kartın emüle edilmiş veya çıkarılabilir olup olmadığına bakılmaksızın, cihaz üreticisinin güvenilir olarak kabul ettiği her SD kart biriminin kök dizini. Güvenilir bir birim, bir uygulamanın çoğu zaman başarıyla erişebildiği bir 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 dosya 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şlem yapma

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

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

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

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

Sağlayıcının desteklediği işlemleri belirleme

Farklı içerik sağlayıcılar, dokümanlar üzerinde farklı işlemlerin (ör. dokümanı kopyalama veya dokümanın küçük resmini görüntüleme) yapılmasına izin verir. Belirli bir sağlayıcının hangi işlemleri desteklediğini belirlemek için Document.COLUMN_FLAGS değerini kontrol edin. Uygulamanızın kullanıcı arayüzü yalnızca sağlayıcının desteklediği seçenekleri gösterebilir.

İzinleri kalıcı hale getirme

Uygulamanız okuma veya yazma için 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. Ancak 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şebilmelerini istediğinizi varsayalım. Kullanıcının cihazı yeniden başlatıldıysa dosyaları bulması için kullanıcıyı sisteme ait seçim aracına geri göndermeniz gerekir.

Cihaz yeniden başlatıldığında dosyalara erişimi korumak ve daha iyi bir kullanıcı deneyimi sunmak için uygulamanız, sistemin sunduğu kalıcı URI izni verme işlemini "alabilir". Bu işlem, aşağıdaki kod snippet'inde gösterilmiştir:

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

Doküman meta verilerini inceleme

Bir dokümanın URI'sine sahip olduğunuzda meta verilerine erişebilirsiniz. Bu snippet, URI tarafından belirtilen bir dokümanın meta verilerini alır ve günlüğe kaydeder:

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

Bir doküman açın.

Bir belgenin URI'sine referans vererek belgeyi daha fazla işlem için açabilirsiniz. Bu bölümde, bit eşlem ve giriş akışı açma örnekleri gösterilmektedir.

Bitmap

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

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

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

Giriş akışı

Aşağıdaki kod snippet'inde, URI'si verilen bir InputStream nesnesinin nasıl açılacağı gösterilmektedir. Bu snippet'te, dosyanın satırları bir dizeye okunur:

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

Doküman düzenleme

Bir metin dokümanını yerinde düzenlemek için Storage Access Framework'ü kullanabilirsiniz.

Aşağıdaki kod snippet'i, verilen URI ile temsil edilen dokümanın içeriğinin üzerine yazar:

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

Belge silme

Bir dokümanın URI'sine sahipseniz ve dokümanın Document.COLUMN_FLAGS değeri SUPPORTS_DELETE içeriyorsa dokümanı silebilirsiniz. Örneğin:

Kotlin

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri)

Java

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri);

Eşdeğer bir medya URI'si alma

getMediaUri() yöntemi, verilen doküman sağlayıcı URI'sine eşdeğer bir medya mağazası URI'si sağlar. İki URI de aynı temel öğeyi ifade eder. Medya deposu URI'sini kullanarak paylaşılan depolama alanındaki medya dosyalarına daha kolay erişebilirsiniz.

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

Sanal dosya açma

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

Sanal dosyaları açmak için istemci uygulamanızın bunları işleyecek özel bir mantık içermesi gerekir. Dosyanın bayt temsilini almak istiyorsanız (örneğin, dosyayı önizlemek için) doküman sağlayıcıdan alternatif bir MIME türü istemeniz gerekir.

Kullanıcı 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:

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

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'inde, sanal bir dosyanın resim olarak gösterilip gösterilemeyeceğinin nasıl kontrol edileceği ve gösterilebiliyorsa sanal dosyadan nasıl giriş akışı alınacağı gösterilmektedir:

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

Ek kaynaklar

Dokümanları ve diğer dosyaları depolama ve bunlara erişme hakkında daha fazla bilgi için aşağıdaki kaynaklara göz atın.

Örnekler

Videolar