Paylaşılan depolama alanındaki medya dosyalarına erişme

Birçok uygulama, daha zengin bir kullanıcı deneyimi sunmak için kullanıcıların harici depolama biriminde bulunan medyaya katkıda bulunmasına ve erişmesine olanak tanır. Çerçeve, kullanıcıların bu medya dosyalarını alıp güncelleyebilmelerini sağlayan, medya deposu adlı medya koleksiyonları için optimize edilmiş bir dizin sunar. Uygulamanızın yüklemesi kaldırılsa bile bu dosyalar kullanıcının cihazında kalır.

Not: Uygulamanız, kullanıcıya yalnızca uygulamanızın içinde değer sağlayan medya dosyalarıyla çalışıyorsa bunları harici depolama alanındaki uygulamaya özel dizinlerde saklamanız önerilir.

Fotoğraf seçici

Android fotoğraf seçici aracı, medya mağazasını kullanmaya alternatif olarak kullanıcıların uygulamanıza tüm medya kitaplıklarına erişim izni vermesine gerek kalmadan medya dosyalarını seçebilecekleri güvenli ve yerleşik bir yöntem sunar. Bu özellik yalnızca desteklenen cihazlarda kullanılabilir. Daha fazla bilgi için fotoğraf seçici kılavuzuna bakın.

Medya mağazası

Dikkat: READ_MEDIA_IMAGES ve READ_MEDIA_VIDEO izinleri, Google Play Politikası'nda belirtilen belirli kullanım alanlarıyla sınırlıdır. Gizliliği korumaya yönelik bir deneyim için fotoğraf seçiciyi kullanmanızı öneririz.

Medya mağazası soyutlamasıyla etkileşim kurmak için uygulamanızın bağlamından aldığınız bir ContentResolver nesnesi kullanın:

Kotlin

val projection = arrayOf(media-database-columns-to-retrieve)
val selection = sql-where-clause-with-placeholder-variables
val selectionArgs = values-of-placeholder-variables
val sortOrder = sql-order-by-clause

applicationContext.contentResolver.query(
    MediaStore.media-type.Media.EXTERNAL_CONTENT_URI,
    projection,
    selection,
    selectionArgs,
    sortOrder
)?.use { cursor ->
    while (cursor.moveToNext()) {
        // Use an ID column from the projection to get
        // a URI representing the media item itself.
    }
}

Java

String[] projection = new String[] {
        media-database-columns-to-retrieve
};
String selection = sql-where-clause-with-placeholder-variables;
String[] selectionArgs = new String[] {
        values-of-placeholder-variables
};
String sortOrder = sql-order-by-clause;

Cursor cursor = getApplicationContext().getContentResolver().query(
    MediaStore.media-type.Media.EXTERNAL_CONTENT_URI,
    projection,
    selection,
    selectionArgs,
    sortOrder
);

while (cursor.moveToNext()) {
    // Use an ID column from the projection to get
    // a URI representing the media item itself.
}

Sistem, harici depolama birimini otomatik olarak tarar ve medya dosyalarını aşağıdaki iyi tanımlanmış koleksiyonlara ekler:

• DCIM/ ve Pictures/ dizinlerinde depolanan fotoğraflar ve ekran görüntüleri dahil resimler. Sistem bu dosyaları MediaStore.Images tablosuna ekler.
• DCIM/, Movies/ ve Pictures/ dizinlerinde depolanan videolar. Sistem bu dosyaları MediaStore.Video tablosuna ekler.
• Alarms/, Audiobooks/, Music/, Notifications/, Podcasts/ ve Ringtones/ dizinlerinde depolanan ses dosyaları. Ayrıca sistem, Music/ veya Movies/ dizinlerindeki ses oynatma listelerinin yanı sıra Recordings/ dizinindeki konuşma kayıtlarını da tanır. Sistem bu dosyaları MediaStore.Audio tablosuna ekler. Recordings/ dizini, Android 11 (API düzeyi 30) ve önceki sürümlerde kullanılamaz.
• Download/ dizininde depolanan indirilen dosyalar. Android 10 (API düzeyi 29) ve sonraki sürümleri çalıştıran cihazlarda bu dosyalar MediaStore.Downloads tablosunda depolanır. Bu tablo, Android 9 (API düzeyi 28) ve önceki sürümlerde kullanılamaz.

Medya mağazasında MediaStore.Files adlı bir koleksiyon da bulunur. İçeriği, uygulamanızın Android 10 veya sonraki sürümleri hedefleyen uygulamalarda kullanılabilen kapsamlı depolama alanını kullanıp kullanmadığına bağlıdır.

• Kapsamlı depolama alanı etkinleştirilirse koleksiyonda yalnızca uygulamanızın oluşturduğu fotoğraflar, videolar ve ses dosyaları gösterilir. Çoğu geliştiricinin diğer uygulamalardaki medya dosyalarını görüntülemek için MediaStore.Files kullanması gerekmez ancak bunu yapmak için özel bir şartınız varsa READ_EXTERNAL_STORAGE iznini beyan edebilirsiniz. Ancak uygulamanızın oluşturmadığı dosyaları açmak için MediaStore API'lerini kullanmanızı öneririz.
• Kapsamlı depolama alanı kullanılamıyorsa veya kullanılmıyorsa koleksiyonda her tür medya dosyası gösterilir.

Gerekli izinleri isteme

Medya dosyaları üzerinde işlem yapmadan önce uygulamanızın bu dosyalara erişmek için gereken izinleri beyan ettiğinden emin olun. Ancak uygulamanızın ihtiyaç duymadığı veya kullanmadığı izinleri belirtmemeye dikkat edin.

Depolama alanı izinleri

Uygulamanızın depolama alanına erişmek için izinlere ihtiyacı olup olmadığı, yalnızca kendi medya dosyalarına mı yoksa diğer uygulamalar tarafından oluşturulan dosyalara mı eriştiğine bağlıdır.

Kendi medya dosyalarınıza erişme

Android 10 veya sonraki sürümlerin yüklü olduğu cihazlarda, MediaStore.Downloads koleksiyonundaki dosyalar da dahil olmak üzere uygulamanıza ait medya dosyalarına erişmek ve bunları değiştirmek için depolama alanıyla ilgili izinlere ihtiyacınız yoktur. Örneğin, bir kamera uygulaması geliştiriyorsanız çektiği fotoğraflara erişmek için depolama alanıyla ilgili izinler istemeniz gerekmez. Çünkü medya deposuna yazdığınız resimler uygulamanıza aittir.

Diğer uygulamaların medya dosyalarına erişme

Diğer uygulamaların oluşturduğu medya dosyalarına erişmek için depolama alanıyla ilgili uygun izinleri beyan etmeniz gerekir. Ayrıca dosyaların aşağıdaki medya koleksiyonlarından birinde bulunması gerekir:

• MediaStore.Images
• MediaStore.Video
• MediaStore.Audio

Bir dosya MediaStore.Images, MediaStore.Video veya MediaStore.Audio sorgularından görüntülenebildiği sürece MediaStore.Files sorgusu kullanılarak da görüntülenebilir.

Aşağıdaki kod snippet'i, uygun depolama alanı izinlerinin nasıl beyan edileceğini gösterir:

<!-- Required only if your app needs to access images or photos
     that other apps created. -->
<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />

<!-- Required only if your app needs to access videos
     that other apps created. -->
<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />

<!-- Required only if your app needs to access audio files
     that other apps created. -->
<uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
                 android:maxSdkVersion="29" />

Not: READ_MEDIA_IMAGES ve READ_MEDIA_VIDEO izinlerini aynı anda isterseniz sistem, her iki izinden de bahseden tek bir çalışma zamanında istenen izin iletişim kutusu gösterir.

Eski cihazlarda çalışan uygulamalar için ek izinler gerekir.

Uygulamanız Android 9 veya daha eski bir sürümün yüklü olduğu bir cihazda kullanılıyorsa ya da uygulamanız geçici olarak kapsamlı depolama alanını devre dışı bıraktıysa herhangi bir medya dosyasına erişmek için READ_EXTERNAL_STORAGE iznini istemeniz gerekir. Medya dosyalarını değiştirmek istiyorsanız WRITE_EXTERNAL_STORAGE iznini de istemeniz gerekir.

Diğer uygulamaların indirmelerine erişmek için Storage Access Framework gerekir.

Uygulamanız, MediaStore.Downloads koleksiyonunda kendisinin oluşturmadığı bir dosyaya erişmek istiyorsa Depolama Alanı Erişim Altyapısı'nı kullanmanız gerekir. Bu çerçeveyi nasıl kullanacağınız hakkında daha fazla bilgi edinmek için Paylaşılan depolama alanındaki dokümanlara ve diğer dosyalara erişme başlıklı makaleyi inceleyin.

Medya konumu izni

Uygulamanız Android 10 (API düzeyi 29) veya sonraki sürümleri hedefliyorsa ve fotoğraflardan düzeltilmemiş EXIF meta verilerini alması gerekiyorsa uygulamanızın manifest dosyasında ACCESS_MEDIA_LOCATION iznini beyan etmeniz ve ardından çalışma zamanında bu izni istemeniz gerekir.

Dikkat: ACCESS_MEDIA_LOCATION iznini çalışma zamanında istediğiniz için uygulamanızın fotoğraflardaki düzeltilmemiş EXIF meta verilerine erişebileceğinin garantisi yoktur. Uygulamanızın bu bilgilere erişebilmesi için kullanıcıdan açık izin alması gerekir.

Medya deposu güncellemelerini kontrol etme

Özellikle uygulamanız URI'leri veya medya deposundaki verileri önbelleğe alıyorsa medya dosyalarına daha güvenilir bir şekilde erişmek için medya deposu sürümünün, medya verilerinizi en son senkronize ettiğiniz zamana göre değişip değişmediğini kontrol edin. Güncellemeler için bu kontrolü gerçekleştirmek üzere getVersion() işlevini çağırın. Döndürülen sürüm, medya mağazası önemli ölçüde değiştiğinde değişen benzersiz bir dizedir. Döndürülen sürüm, son senkronize edilen sürümden farklıysa uygulamanızın medya önbelleğini yeniden tarayın ve yeniden senkronize edin.

Bu kontrolü uygulama işlemi başlatılırken yapın. Medya deposunu her sorguladığınızda sürümü kontrol etmeniz gerekmez.

Sürüm numarasıyla ilgili herhangi bir uygulama ayrıntısı varsaymayın.

Not: Medya deposu sürüm numarası, uygulama tarafındaki değişiklikler (ör. bir uygulamanın medya dosyası eklemesi) sonucunda değişmez. Medya dosyalarındaki güncellemeleri tespit etmenize yardımcı olacak ayrı bir yöntem vardır.

Medya koleksiyonunu sorgulama

Belirli bir koşul grubunu (ör. 5 dakika veya daha uzun süre) karşılayan medyaları bulmak için aşağıdaki kod snippet'inde gösterilene benzer bir SQL benzeri seçim ifadesi kullanın:

Kotlin

// Need the READ_EXTERNAL_STORAGE permission if accessing video files that your
// app didn't create.

// Container for information about each video.
data class Video(val uri: Uri,
    val name: String,
    val duration: Int,
    val size: Int
)
val videoList = mutableListOf<Video>()

val collection =
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        MediaStore.Video.Media.getContentUri(
            MediaStore.VOLUME_EXTERNAL
        )
    } else {
        MediaStore.Video.Media.EXTERNAL_CONTENT_URI
    }

val projection = arrayOf(
    MediaStore.Video.Media._ID,
    MediaStore.Video.Media.DISPLAY_NAME,
    MediaStore.Video.Media.DURATION,
    MediaStore.Video.Media.SIZE
)

// Show only videos that are at least 5 minutes in duration.
val selection = "${MediaStore.Video.Media.DURATION} >= ?"
val selectionArgs = arrayOf(
    TimeUnit.MILLISECONDS.convert(5, TimeUnit.MINUTES).toString()
)

// Display videos in alphabetical order based on their display name.
val sortOrder = "${MediaStore.Video.Media.DISPLAY_NAME} ASC"

val query = ContentResolver.query(
    collection,
    projection,
    selection,
    selectionArgs,
    sortOrder
)
query?.use { cursor ->
    // Cache column indices.
    val idColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID)
    val nameColumn =
            cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME)
    val durationColumn =
            cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION)
    val sizeColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE)

    while (cursor.moveToNext()) {
        // Get values of columns for a given video.
        val id = cursor.getLong(idColumn)
        val name = cursor.getString(nameColumn)
        val duration = cursor.getInt(durationColumn)
        val size = cursor.getInt(sizeColumn)

        val contentUri: Uri = ContentUris.withAppendedId(
            MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
            id
        )

        // Stores column values and the contentUri in a local object
        // that represents the media file.
        videoList += Video(contentUri, name, duration, size)
    }
}

Java

// Need the READ_EXTERNAL_STORAGE permission if accessing video files that your
// app didn't create.

// Container for information about each video.
class Video {
    private final Uri uri;
    private final String name;
    private final int duration;
    private final int size;

    public Video(Uri uri, String name, int duration, int size) {
        this.uri = uri;
        this.name = name;
        this.duration = duration;
        this.size = size;
    }
}
List<Video> videoList = new ArrayList<Video>();

Uri collection;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    collection = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL);
} else {
    collection = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
}

String[] projection = new String[] {
    MediaStore.Video.Media._ID,
    MediaStore.Video.Media.DISPLAY_NAME,
    MediaStore.Video.Media.DURATION,
    MediaStore.Video.Media.SIZE
};
String selection = MediaStore.Video.Media.DURATION +
        " >= ?";
String[] selectionArgs = new String[] {
    String.valueOf(TimeUnit.MILLISECONDS.convert(5, TimeUnit.MINUTES));
};
String sortOrder = MediaStore.Video.Media.DISPLAY_NAME + " ASC";

try (Cursor cursor = getApplicationContext().getContentResolver().query(
    collection,
    projection,
    selection,
    selectionArgs,
    sortOrder
)) {
    // Cache column indices.
    int idColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID);
    int nameColumn =
            cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME);
    int durationColumn =
            cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION);
    int sizeColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE);

    while (cursor.moveToNext()) {
        // Get values of columns for a given video.
        long id = cursor.getLong(idColumn);
        String name = cursor.getString(nameColumn);
        int duration = cursor.getInt(durationColumn);
        int size = cursor.getInt(sizeColumn);

        Uri contentUri = ContentUris.withAppendedId(
                MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id);

        // Stores column values and the contentUri in a local object
        // that represents the media file.
        videoList.add(new Video(contentUri, name, duration, size));
    }
}

Uygulamanızda bu tür bir sorgu gerçekleştirirken aşağıdakileri göz önünde bulundurun:

• Çalışan iş parçacığında query() yöntemini çağırın.
• Sorgu sonucundaki bir satırı her işlediğinizde getColumnIndexOrThrow() yöntemini çağırmanız gerekmemesi için sütun dizinlerini önbelleğe alın.
• Kimliği, bu örnekte gösterildiği gibi içerik URI'sine ekleyin.
• Android 10 ve sonraki sürümleri çalıştıran cihazlar, MediaStore API'de tanımlanan sütun adlarını gerektirir. Uygulamanızdaki bağımlı bir kitaplık, API'de tanımlanmamış bir sütun adı (ör. "MimeType") bekliyorsa uygulamanızın işleminde sütun adını dinamik olarak çevirmek için CursorWrapper kullanın.

Dosya küçük resimlerini yükleme

Uygulamanız birden fazla medya dosyası gösteriyor ve kullanıcıdan bu dosyalardan birini seçmesini istiyorsa dosyaların kendileri yerine önizleme sürümlerini veya küçük resimlerini yüklemek daha verimli olur.

Belirli bir medya dosyasının küçük resmini yüklemek için loadThumbnail() yöntemini kullanın ve yüklemek istediğiniz küçük resmin boyutunu aşağıdaki kod snippet'inde gösterildiği gibi iletin:

Kotlin

// Load thumbnail of a specific media item.
val thumbnail: Bitmap =
        applicationContext.contentResolver.loadThumbnail(
        content-uri, Size(640, 480), null)

Java

// Load thumbnail of a specific media item.
Bitmap thumbnail =
        getApplicationContext().getContentResolver().loadThumbnail(
        content-uri, new Size(640, 480), null);

Medya dosyası açma

Bir medya dosyasını açmak için kullandığınız mantık, medya içeriğinin en iyi şekilde dosya tanımlayıcı, dosya akışı veya doğrudan dosya yolu olarak temsil edilip edilmediğine bağlıdır.

Dosya tanımlayıcı

Bir medya dosyasını dosya tanımlayıcı kullanarak açmak için aşağıdaki kod snippet'inde gösterilene benzer bir mantık kullanın:

Kotlin

// Open a specific media item using ParcelFileDescriptor.
val resolver = applicationContext.contentResolver

// "rw" for read-and-write.
// "rwt" for truncating or overwriting existing file contents.
val readOnlyMode = "r"
resolver.openFileDescriptor(content-uri, readOnlyMode).use { pfd ->
    // Perform operations on "pfd".
}

Java

// Open a specific media item using ParcelFileDescriptor.
ContentResolver resolver = getApplicationContext()
        .getContentResolver();

// "rw" for read-and-write.
// "rwt" for truncating or overwriting existing file contents.
String readOnlyMode = "r";
try (ParcelFileDescriptor pfd =
        resolver.openFileDescriptor(content-uri, readOnlyMode)) {
    // Perform operations on "pfd".
} catch (IOException e) {
    e.printStackTrace();
}

Dosya akışı

Dosya akışı kullanarak medya dosyası açmak için aşağıdaki kod snippet'inde gösterilene benzer bir mantık kullanın:

Kotlin

// Open a specific media item using InputStream.
val resolver = applicationContext.contentResolver
resolver.openInputStream(content-uri).use { stream ->
    // Perform operations on "stream".
}

Java

// Open a specific media item using InputStream.
ContentResolver resolver = getApplicationContext()
        .getContentResolver();
try (InputStream stream = resolver.openInputStream(content-uri)) {
    // Perform operations on "stream".
}

Doğrudan dosya yolları

Uygulamanızın üçüncü taraf medya kitaplıklarıyla daha sorunsuz çalışmasına yardımcı olmak için Android 11 (API düzeyi 30) ve sonraki sürümler, paylaşılan depolama alanındaki medya dosyalarına erişmek için MediaStore API dışındaki API'leri kullanmanıza olanak tanır. Bunun yerine, aşağıdaki API'lerden birini kullanarak medya dosyalarına doğrudan erişebilirsiniz:

• File API'si
• fopen() gibi yerel kitaplıklar

Depolama alanıyla ilgili herhangi bir izniniz yoksa File API'yi kullanarak uygulamaya özel dizininizdeki dosyalara ve uygulamanızla ilişkilendirilen medya dosyalarına erişebilirsiniz.

Uygulamanız File API'yi kullanarak bir dosyaya erişmeye çalışırsa ve gerekli izinlere sahip değilse FileNotFoundException hatası oluşur.

Android 10 (API düzeyi 29) yüklü bir cihazda paylaşılan depolama alanındaki diğer dosyalara erişmek için uygulamanızın manifest dosyasında requestLegacyExternalStorage değerini true olarak ayarlayarak kapsamlı depolama alanını geçici olarak devre dışı bırakmanızı öneririz. Android 10'da yerel dosya yöntemlerini kullanarak medya dosyalarına erişmek için READ_EXTERNAL_STORAGE iznini de istemeniz gerekir.

Medya içeriğine erişirken dikkat edilmesi gereken noktalar

Medya içeriğine erişirken aşağıdaki bölümlerde ele alınan hususları göz önünde bulundurun.

Önbelleğe alınan veriler

Uygulamanız, medya mağazasındaki URI'leri veya verileri önbelleğe alıyorsa düzenli olarak medya mağazasındaki güncellemeleri kontrol edin. Bu kontrol, uygulama tarafındaki önbelleğe alınmış verilerinizin sistem tarafındaki sağlayıcı verileriyle senkronize kalmasını sağlar.

Performans

Doğrudan dosya yollarını kullanarak medya dosyalarını sıralı olarak okuduğunuzda performans, MediaStore API'ninkiyle karşılaştırılabilir düzeydedir.

Ancak doğrudan dosya yollarını kullanarak medya dosyalarını rastgele okuyup yazarken işlem iki kat daha yavaş olabilir. Bu durumlarda, bunun yerine MediaStore API'yi kullanmanızı öneririz.

DATA sütunu

Mevcut bir medya dosyasına eriştiğinizde mantığınızda DATA sütununun değerini kullanabilirsiniz. Bunun nedeni, bu değerin geçerli bir dosya yoluna sahip olmasıdır. Ancak dosyanın her zaman kullanılabilir olduğunu varsaymayın. Dosya tabanlı G/Ç hatalarını ele almaya hazır olun.

Medya dosyası oluşturmak veya güncellemek için ise DATA sütununun değerini kullanmayın. Bunun yerine, DISPLAY_NAME ve RELATIVE_PATH sütunlarının değerlerini kullanın.

Depolama birimleri

Android 10 veya sonraki sürümleri hedefleyen uygulamalar, sistemin her harici depolama birimine atadığı benzersiz ada erişebilir. Bu adlandırma sistemi, içeriği verimli bir şekilde düzenlemenize ve dizine eklemenize yardımcı olur ve yeni medya dosyalarının nerede depolanacağı konusunda kontrol sahibi olmanızı sağlar.

Aşağıdaki hacimler özellikle dikkate alınmalıdır:

• VOLUME_EXTERNAL birimi, cihazdaki tüm paylaşılan depolama birimlerinin görünümünü sağlar. Bu yapay birimin içeriğini okuyabilirsiniz ancak içeriği değiştiremezsiniz.
• VOLUME_EXTERNAL_PRIMARY birimi, cihazdaki birincil paylaşılan depolama birimini temsil eder. Bu birimin içeriğini okuyabilir ve değiştirebilirsiniz.

MediaStore.getExternalVolumeNames() işlevini çağırarak diğer birimleri keşfedebilirsiniz:

Kotlin

val volumeNames: Set<String> = MediaStore.getExternalVolumeNames(context)
val firstVolumeName = volumeNames.iterator().next()

Java

Set<String> volumeNames = MediaStore.getExternalVolumeNames(context);
String firstVolumeName = volumeNames.iterator().next();

Medyanın çekildiği konum

Bazı fotoğraf ve videoların meta verilerinde, fotoğrafın çekildiği veya videonun kaydedildiği yeri gösteren konum bilgileri bulunur.

Uygulamanızda bu konum bilgilerine nasıl erişeceğiniz, bir fotoğrafın mı yoksa videonun mu konum bilgilerine erişmeniz gerektiğine bağlıdır.

Fotoğraflar

Uygulamanız kapsamlı depolama alanı kullanıyorsa sistem, konum bilgilerini varsayılan olarak gizler. Bu bilgilere erişmek için aşağıdaki adımları uygulayın:

1. Uygulamanızın manifest dosyasında ACCESS_MEDIA_LOCATION iznini isteyin.

2. MediaStore nesnenizden, setRequireOriginal() yöntemini çağırıp fotoğrafın URI'sini ileterek fotoğrafın tam bayt değerini alın. Bu işlem, aşağıdaki kod snippet'inde gösterilmiştir:

   Kotlin

   val photoUri: Uri = Uri.withAppendedPath(
           MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
           cursor.getString(idColumnIndex)
   )
   
   // Get location data using the Exifinterface library.
   // Exception occurs if ACCESS_MEDIA_LOCATION permission isn't granted.
   photoUri = MediaStore.setRequireOriginal(photoUri)
   contentResolver.openInputStream(photoUri)?.use { stream ->
       ExifInterface(stream).run {
           // If lat/long is null, fall back to the coordinates (0, 0).
           val latLong = latLong ?: doubleArrayOf(0.0, 0.0)
       }
   }

   Java

   Uri photoUri = Uri.withAppendedPath(
           MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
           cursor.getString(idColumnIndex));
   
   final double[] latLong;
   
   // Get location data using the Exifinterface library.
   // Exception occurs if ACCESS_MEDIA_LOCATION permission isn't granted.
   photoUri = MediaStore.setRequireOriginal(photoUri);
   InputStream stream = getContentResolver().openInputStream(photoUri);
   if (stream != null) {
       ExifInterface exifInterface = new ExifInterface(stream);
       double[] returnedLatLong = exifInterface.getLatLong();
   
       // If lat/long is null, fall back to the coordinates (0, 0).
       latLong = returnedLatLong != null ? returnedLatLong : new double[2];
   
       // Don't reuse the stream associated with
       // the instance of "ExifInterface".
       stream.close();
   } else {
       // Failed to load the stream, so return the coordinates (0, 0).
       latLong = new double[2];
   }

Videolar

Bir videonun meta verilerindeki konum bilgilerine erişmek için aşağıdaki kod snippet'inde gösterildiği gibi MediaMetadataRetriever sınıfını kullanın. Uygulamanızın bu sınıfı kullanmak için ek izin istemesi gerekmez.

Kotlin

val retriever = MediaMetadataRetriever()
val context = applicationContext

// Find the videos that are stored on a device by querying the video collection.
val query = ContentResolver.query(
    collection,
    projection,
    selection,
    selectionArgs,
    sortOrder
)
query?.use { cursor ->
    val idColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID)
    while (cursor.moveToNext()) {
        val id = cursor.getLong(idColumn)
        val videoUri: Uri = ContentUris.withAppendedId(
            MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
            id
        )
        extractVideoLocationInfo(videoUri)
    }
}

private fun extractVideoLocationInfo(videoUri: Uri) {
    try {
        retriever.setDataSource(context, videoUri)
    } catch (e: RuntimeException) {
        Log.e(APP_TAG, "Cannot retrieve video file", e)
    }
    // Metadata uses a standardized format.
    val locationMetadata: String? =
            retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_LOCATION)
}

Java

MediaMetadataRetriever retriever = new MediaMetadataRetriever();
Context context = getApplicationContext();

// Find the videos that are stored on a device by querying the video collection.
try (Cursor cursor = context.getContentResolver().query(
    collection,
    projection,
    selection,
    selectionArgs,
    sortOrder
)) {
    int idColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID);
    while (cursor.moveToNext()) {
        long id = cursor.getLong(idColumn);
        Uri videoUri = ContentUris.withAppendedId(
                MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id);
        extractVideoLocationInfo(videoUri);
    }
}

private void extractVideoLocationInfo(Uri videoUri) {
    try {
        retriever.setDataSource(context, videoUri);
    } catch (RuntimeException e) {
        Log.e(APP_TAG, "Cannot retrieve video file", e);
    }
    // Metadata uses a standardized format.
    String locationMetadata = retriever.extractMetadata(
            MediaMetadataRetriever.METADATA_KEY_LOCATION);
}

Paylaşım

Bazı uygulamalar, kullanıcıların birbirleriyle medya dosyası paylaşmasına olanak tanır. Örneğin, sosyal medya uygulamaları, kullanıcıların arkadaşlarıyla fotoğraf ve video paylaşmasına olanak tanır.

Medya dosyalarını paylaşmak için İçerik sağlayıcı oluşturma kılavuzunda önerildiği gibi bir content:// URI'si kullanın.

Medya dosyalarının uygulama ilişkilendirmesi

Android 10 veya sonraki sürümleri hedefleyen bir uygulama için kapsamlı depolama alanı etkinleştirildiğinde sistem, her medya dosyası için bir uygulama atfı yapar. Bu, uygulamanızın herhangi bir depolama alanı izni istemediğinde erişebileceği dosyaları belirler. Her dosya yalnızca bir uygulamayla ilişkilendirilebilir. Bu nedenle, uygulamanız fotoğraflar, videolar veya ses dosyaları medya koleksiyonunda depolanan bir medya dosyası oluşturursa uygulamanız bu dosyaya erişebilir.

Ancak kullanıcı uygulamanızı kaldırıp yeniden yüklerse uygulamanızın başlangıçta oluşturduğu dosyalara erişmek için READ_EXTERNAL_STORAGE izni istemeniz gerekir. Sistem, dosyanın yeni yüklenen sürüm yerine uygulamanın daha önce yüklenen sürümüyle ilişkilendirildiğini düşündüğü için bu izin isteği gereklidir.

Android 16 veya sonraki sürümleri çalıştıran cihazlarda SDK 36 ya da sonraki sürümleri hedefleyen bir uygulama tarafından fotoğraf ve video izinleri istendiğinde, seçili medyaya erişimi sınırlamayı tercih eden kullanıcılar, uygulamaya ait tüm fotoğrafların fotoğraf seçicide önceden seçildiğini görür. Kullanıcılar, önceden seçilmiş bu öğelerden herhangi birinin seçimini kaldırabilir. Bu durumda uygulamanın söz konusu fotoğraf ve videolara erişimi iptal edilir.

Öğe ekleyin

Mevcut bir koleksiyona medya öğesi eklemek için aşağıdakine benzer bir kod kullanın. Bu kod snippet'i, Android 10 veya sonraki sürümleri çalıştıran cihazlarda VOLUME_EXTERNAL_PRIMARY birimine erişir. Bunun nedeni, bu cihazlarda yalnızca birincil birimlerin içeriğini değiştirebilmenizdir. Bu konu, Depolama birimleri bölümünde açıklanmıştır.

Kotlin

// Add a specific media item.
val resolver = applicationContext.contentResolver

// Find all audio files on the primary external storage device.
val audioCollection =
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        MediaStore.Audio.Media.getContentUri(
            MediaStore.VOLUME_EXTERNAL_PRIMARY
        )
    } else {
        MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
    }

// Publish a new song.
val newSongDetails = ContentValues().apply {
    put(MediaStore.Audio.Media.DISPLAY_NAME, "My Song.mp3")
}

// Keep a handle to the new song's URI in case you need to modify it
// later.
val myFavoriteSongUri = resolver
        .insert(audioCollection, newSongDetails)

Java

// Add a specific media item.
ContentResolver resolver = getApplicationContext()
        .getContentResolver();

// Find all audio files on the primary external storage device.
Uri audioCollection;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    audioCollection = MediaStore.Audio.Media
            .getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
} else {
    audioCollection = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
}

// Publish a new song.
ContentValues newSongDetails = new ContentValues();
newSongDetails.put(MediaStore.Audio.Media.DISPLAY_NAME,
        "My Song.mp3");

// Keep a handle to the new song's URI in case you need to modify it
// later.
Uri myFavoriteSongUri = resolver
        .insert(audioCollection, newSongDetails);

Medya dosyaları için bekleme durumunu aç/kapat

Uygulamanız, medya dosyalarına yazma gibi zaman alabilecek işlemler gerçekleştiriyorsa işlenirken dosyaya özel erişiminizin olması faydalıdır. Android 10 veya sonraki sürümlerin yüklü olduğu cihazlarda uygulamanız, IS_PENDING işaretinin değerini 1 olarak ayarlayarak bu özel erişimi elde edebilir. Uygulamanız IS_PENDING değerini tekrar 0 olarak değiştirene kadar dosyayı yalnızca uygulamanız görüntüleyebilir.

Aşağıdaki kod snippet'i, önceki kod snippet'ini temel alır. Bu snippet, MediaStore.Audio koleksiyonuna karşılık gelen dizinde uzun bir şarkı depolarken IS_PENDING işaretinin nasıl kullanılacağını gösterir:

Kotlin

// Add a media item that other apps don't see until the item is
// fully written to the media store.
val resolver = applicationContext.contentResolver

// Find all audio files on the primary external storage device.
val audioCollection =
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        MediaStore.Audio.Media.getContentUri(
            MediaStore.VOLUME_EXTERNAL_PRIMARY
        )
    } else {
        MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
    }

val songDetails = ContentValues().apply {
    put(MediaStore.Audio.Media.DISPLAY_NAME, "My Workout Playlist.mp3")
    put(MediaStore.Audio.Media.IS_PENDING, 1)
}

val songContentUri = resolver.insert(audioCollection, songDetails)

// "w" for write.
resolver.openFileDescriptor(songContentUri, "w", null).use { pfd ->
    // Write data into the pending audio file.
}

// Now that you're finished, release the "pending" status and let other apps
// play the audio track.
songDetails.clear()
songDetails.put(MediaStore.Audio.Media.IS_PENDING, 0)
resolver.update(songContentUri, songDetails, null, null)

Java

// Add a media item that other apps don't see until the item is
// fully written to the media store.
ContentResolver resolver = getApplicationContext()
        .getContentResolver();

// Find all audio files on the primary external storage device.
Uri audioCollection;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
    audioCollection = MediaStore.Audio.Media
            .getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
} else {
    audioCollection = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
}

ContentValues songDetails = new ContentValues();
songDetails.put(MediaStore.Audio.Media.DISPLAY_NAME,
        "My Workout Playlist.mp3");
songDetails.put(MediaStore.Audio.Media.IS_PENDING, 1);

Uri songContentUri = resolver
        .insert(audioCollection, songDetails);

// "w" for write.
try (ParcelFileDescriptor pfd =
        resolver.openFileDescriptor(songContentUri, "w", null)) {
    // Write data into the pending audio file.
}

// Now that you're finished, release the "pending" status and let other apps
// play the audio track.
songDetails.clear();
songDetails.put(MediaStore.Audio.Media.IS_PENDING, 0);
resolver.update(songContentUri, songDetails, null, null);

Dosya konumu için ipucu verin

Uygulamanız Android 10 çalıştıran bir cihazda medya depoladığında medya varsayılan olarak türüne göre düzenlenir. Örneğin, varsayılan olarak yeni resim dosyaları, MediaStore.Images koleksiyonuna karşılık gelen Environment.DIRECTORY_PICTURES dizinine yerleştirilir.

Uygulamanız, dosyaların depolanabileceği belirli bir konumun (ör. Pictures/MyVacationPictures adlı bir fotoğraf albümü) farkındaysa sisteme yeni yazılan dosyaların nerede depolanacağıyla ilgili bir ipucu sağlamak için MediaColumns.RELATIVE_PATH değerini ayarlayabilirsiniz.

Not: Medya dışı dosyalar da dahil olmak üzere genel amaçlı dosyaları Documents/ veya Download/ klasöründe depolamak mümkün olsa da bu kullanım alanları için Depolama Alanı Erişim Çerçevesi'ni kullanmak daha iyidir.

Öğeleri güncelleme

Uygulamanızın sahip olduğu bir medya dosyasını güncellemek için aşağıdakine benzer bir kod kullanın:

Kotlin

// Updates an existing media item.
val mediaId = // MediaStore.Audio.Media._ID of item to update.
val resolver = applicationContext.contentResolver

// When performing a single item update, prefer using the ID.
val selection = "${MediaStore.Audio.Media._ID} = ?"

// By using selection + args you protect against improper escaping of // values.
val selectionArgs = arrayOf(mediaId.toString())

// Update an existing song.
val updatedSongDetails = ContentValues().apply {
    put(MediaStore.Audio.Media.DISPLAY_NAME, "My Favorite Song.mp3")
}

// Use the individual song's URI to represent the collection that's
// updated.
val numSongsUpdated = resolver.update(
        myFavoriteSongUri,
        updatedSongDetails,
        selection,
        selectionArgs)

Java

// Updates an existing media item.
long mediaId = // MediaStore.Audio.Media._ID of item to update.
ContentResolver resolver = getApplicationContext()
        .getContentResolver();

// When performing a single item update, prefer using the ID.
String selection = MediaStore.Audio.Media._ID + " = ?";

// By using selection + args you protect against improper escaping of
// values. Here, "song" is an in-memory object that caches the song's
// information.
String[] selectionArgs = new String[] { getId().toString() };

// Update an existing song.
ContentValues updatedSongDetails = new ContentValues();
updatedSongDetails.put(MediaStore.Audio.Media.DISPLAY_NAME,
        "My Favorite Song.mp3");

// Use the individual song's URI to represent the collection that's
// updated.
int numSongsUpdated = resolver.update(
        myFavoriteSongUri,
        updatedSongDetails,
        selection,
        selectionArgs);

Kapsamlı depolama alanı kullanılamıyorsa veya etkinleştirilmemişse yukarıdaki kod snippet'inde gösterilen işlem, uygulamanıza ait olmayan dosyalar için de geçerlidir.

Not: MediaColumns.RELATIVE_PATH veya MediaColumns.DISPLAY_NAME değerini değiştirerek update() çağrısı sırasında diskteki dosyaları taşıyabilirsiniz.

Yerel kodda güncelleme

Yerel kitaplıkları kullanarak medya dosyaları yazmanız gerekiyorsa dosyanın ilişkili dosya tanımlayıcısını Java tabanlı veya Kotlin tabanlı kodunuzdan yerel kodunuza iletin.

Aşağıdaki kod snippet'inde, bir medya nesnesinin dosya tanımlayıcısının uygulamanızın yerel koduna nasıl iletileceği gösterilmektedir:

Kotlin

val contentUri: Uri = ContentUris.withAppendedId(
        MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
        cursor.getLong(BaseColumns._ID))
val fileOpenMode = "r"
val parcelFd = resolver.openFileDescriptor(contentUri, fileOpenMode)
val fd = parcelFd?.detachFd()
// Pass the integer value "fd" into your native code. Remember to call
// close(2) on the file descriptor when you're done using it.

Java

Uri contentUri = ContentUris.withAppendedId(
        MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
        cursor.getLong(Integer.parseInt(BaseColumns._ID)));
String fileOpenMode = "r";
ParcelFileDescriptor parcelFd =
        resolver.openFileDescriptor(contentUri, fileOpenMode);
if (parcelFd != null) {
    int fd = parcelFd.detachFd();
    // Pass the integer value "fd" into your native code. Remember to call
    // close(2) on the file descriptor when you're done using it.
}

Diğer uygulamaların medya dosyalarını güncelleme

Uygulamanız kapsamlı depolama alanı kullanıyorsa normalde farklı bir uygulamanın medya mağazasına eklediği medya dosyasını güncelleyemez.

Ancak platformun oluşturduğu RecoverableSecurityException öğesini yakalayarak dosyayı değiştirmek için kullanıcı izni alabilirsiniz. Ardından, aşağıdaki kod snippet'inde gösterildiği gibi, kullanıcının uygulamanıza söz konusu öğe için yazma erişimi vermesini isteyebilirsiniz:

Kotlin

// Apply a grayscale filter to the image at the given content URI.
try {
    // "w" for write.
    contentResolver.openFileDescriptor(image-content-uri, "w")?.use {
        setGrayscaleFilter(it)
    }
} catch (securityException: SecurityException) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        val recoverableSecurityException = securityException as?
            RecoverableSecurityException ?:
            throw RuntimeException(securityException.message, securityException)

        val intentSender =
            recoverableSecurityException.userAction.actionIntent.intentSender
        intentSender?.let {
            startIntentSenderForResult(intentSender, image-request-code,
                    null, 0, 0, 0, null)
        }
    } else {
        throw RuntimeException(securityException.message, securityException)
    }
}

Java

try {
    // "w" for write.
    ParcelFileDescriptor imageFd = getContentResolver()
            .openFileDescriptor(image-content-uri, "w");
    setGrayscaleFilter(imageFd);
} catch (SecurityException securityException) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        RecoverableSecurityException recoverableSecurityException;
        if (securityException instanceof RecoverableSecurityException) {
            recoverableSecurityException =
                    (RecoverableSecurityException)securityException;
        } else {
            throw new RuntimeException(
                    securityException.getMessage(), securityException);
        }
        IntentSender intentSender =recoverableSecurityException.getUserAction()
                .getActionIntent().getIntentSender();
        startIntentSenderForResult(intentSender, image-request-code,
                null, 0, 0, 0, null);
    } else {
        throw new RuntimeException(
                securityException.getMessage(), securityException);
    }
}

Uygulamanızın, kendisi tarafından oluşturulmamış bir medya dosyasını değiştirmesi gerektiğinde bu işlemi tamamlayın.

Alternatif olarak, uygulamanız Android 11 veya sonraki sürümlerde çalışıyorsa kullanıcıların uygulamanıza bir grup medya dosyası için yazma erişimi vermesine izin verebilirsiniz. Medya dosyası gruplarını yönetme bölümünde açıklandığı gibi createWriteRequest() yöntemini kullanın.

Uygulamanızın kapsamlı depolama alanının kapsamadığı başka bir kullanım alanı varsa özellik isteğinde bulunun ve kapsamlı depolama alanını geçici olarak devre dışı bırakın.

Öğe kaldırma

Uygulamanızın artık medya mağazasında ihtiyaç duymadığı bir öğeyi kaldırmak için aşağıdaki kod snippet'inde gösterilene benzer bir mantık kullanın:

Kotlin

// Remove a specific media item.
val resolver = applicationContext.contentResolver

// URI of the image to remove.
val imageUri = "..."

// WHERE clause.
val selection = "..."
val selectionArgs = "..."

// Perform the actual removal.
val numImagesRemoved = resolver.delete(
        imageUri,
        selection,
        selectionArgs)

Java

// Remove a specific media item.
ContentResolver resolver = getApplicationContext()
        getContentResolver();

// URI of the image to remove.
Uri imageUri = "...";

// WHERE clause.
String selection = "...";
String[] selectionArgs = "...";

// Perform the actual removal.
int numImagesRemoved = resolver.delete(
        imageUri,
        selection,
        selectionArgs);

Kapsamlı depolama alanı kullanılamıyorsa veya etkinleştirilmemişse diğer uygulamalara ait dosyaları kaldırmak için yukarıdaki kod snippet'ini kullanabilirsiniz. Ancak kapsamlı depolama alanı etkinse uygulamanızın kaldırmak istediği her dosya için medya öğelerini güncelleme bölümünde açıklandığı gibi bir RecoverableSecurityException yakalamanız gerekir.

Uygulamanız Android 11 veya sonraki sürümlerde çalışıyorsa kullanıcıların kaldırılacak bir medya dosyası grubu seçmesine izin verebilirsiniz. Medya dosyası gruplarını yönetme ile ilgili bölümde açıklandığı gibi createTrashRequest() yöntemini veya createDeleteRequest() yöntemini kullanın.

Uygulamanızın kapsamlı depolama alanının kapsamadığı başka bir kullanım alanı varsa özellik isteğinde bulunun ve kapsamlı depolama alanını geçici olarak devre dışı bırakın.

Medya dosyalarındaki güncellemeleri algılama

Uygulamanızın, önceki bir zaman noktasına kıyasla uygulamaların eklediği veya değiştirdiği medya dosyalarını içeren depolama birimlerini tanımlaması gerekebilir. Bu değişiklikleri en güvenilir şekilde algılamak için ilgili depolama birimini getGeneration() yöntemine iletin. Medya mağazası sürümü değişmediği sürece bu yöntemin döndürdüğü değer zaman içinde monoton bir şekilde artar.

Özellikle getGeneration(), medya sütunlarındaki tarihlerden (ör. DATE_ADDED ve DATE_MODIFIED) daha sağlamdır. Bunun nedeni, bir uygulama setLastModified() yöntemini çağırdığında veya kullanıcı sistem saatini değiştirdiğinde bu medya sütunu değerlerinin değişebilmesidir.

Dikkat: getGeneration() değerini kullanmadan önce güncellemeler için medya mağazasını kontrol edin. Medya deposu sürümü değiştiyse tam senkronizasyon gerçekleştirin.

Medya dosyası gruplarını yönetme

Android 11 ve sonraki sürümlerde, kullanıcıdan bir medya dosyası grubu seçmesini isteyebilir, ardından bu medya dosyalarını tek bir işlemde güncelleyebilirsiniz. Bu yöntemler, cihazlar arasında daha iyi tutarlılık sağlar ve kullanıcıların medya koleksiyonlarını yönetmesini kolaylaştırır.

Bu "toplu güncelleme" işlevini sağlayan yöntemler şunlardır:

createWriteRequest()

Kullanıcıdan, uygulamanıza belirtilen medya dosyası grubuna yazma erişimi vermesini isteyin.

createFavoriteRequest()

Kullanıcıdan, belirtilen medya dosyalarını cihazdaki "favori" medyalarından bazıları olarak işaretlemesini isteyin. Bu dosyaya okuma erişimi olan tüm uygulamalar, kullanıcının dosyayı "favori" olarak işaretlediğini görebilir.

createTrashRequest()

Kullanıcıdan, belirtilen medya dosyalarını cihazın çöp kutusuna taşımasını isteyin. Çöp kutusundaki öğeler, sistem tarafından tanımlanan bir sürenin ardından kalıcı olarak silinir.

Not: Uygulamanız, cihaz OEM'inin önceden yüklenmiş galeri uygulamasıysa iletişim kutusu göstermeden dosyaları çöp kutusuna taşıyabilirsiniz. Bunun için IS_TRASHED değerini doğrudan 1 olarak ayarlayın.

createDeleteRequest()

Kullanıcıdan, belirtilen medya dosyalarını önceden çöp kutusuna taşımadan hemen kalıcı olarak silmesini isteyin.

Bu yöntemlerden herhangi biri çağrıldıktan sonra sistem bir PendingIntent nesnesi oluşturur. Uygulamanız bu intent'i çağırdıktan sonra kullanıcılar, uygulamanızın belirtilen medya dosyalarını güncellemesi veya silmesi için izin isteyen bir iletişim kutusu görür.

Örneğin, createWriteRequest() çağrısını şu şekilde yapılandırabilirsiniz:

Kotlin

val urisToModify = /* A collection of content URIs to modify. */
val editPendingIntent = MediaStore.createWriteRequest(contentResolver,
        urisToModify)

// Launch a system prompt requesting user permission for the operation.
startIntentSenderForResult(editPendingIntent.intentSender, EDIT_REQUEST_CODE,
    null, 0, 0, 0)

Java

List<Uri> urisToModify = /* A collection of content URIs to modify. */
PendingIntent editPendingIntent = MediaStore.createWriteRequest(contentResolver,
                  urisToModify);

// Launch a system prompt requesting user permission for the operation.
startIntentSenderForResult(editPendingIntent.getIntentSender(),
    EDIT_REQUEST_CODE, null, 0, 0, 0);

Kullanıcının yanıtını değerlendirin. Kullanıcı izin verdiyse medya işlemine devam edin. Aksi takdirde, uygulamanızın neden izne ihtiyacı olduğunu kullanıcıya açıklayın:

Kotlin

override fun onActivityResult(requestCode: Int, resultCode: Int,
                 data: Intent?) {
    ...
    when (requestCode) {
        EDIT_REQUEST_CODE ->
            if (resultCode == Activity.RESULT_OK) {
                /* Edit request granted; proceed. */
            } else {
                /* Edit request not granted; explain to the user. */
            }
    }
}

Java

@Override
protected void onActivityResult(int requestCode, int resultCode,
                   @Nullable Intent data) {
    ...
    if (requestCode == EDIT_REQUEST_CODE) {
        if (resultCode == Activity.RESULT_OK) {
            /* Edit request granted; proceed. */
        } else {
            /* Edit request not granted; explain to the user. */
        }
    }
}

Aynı genel kalıbı createFavoriteRequest(), createTrashRequest() ve createDeleteRequest() ile kullanabilirsiniz.

Medya yönetimi izni

Kullanıcılar, medya dosyalarında sık sık düzenleme yapmak gibi medya yönetimi işlemleri için belirli bir uygulamaya güvenebilir. Uygulamanız Android 11 veya sonraki sürümleri hedefliyorsa ve cihazın varsayılan galeri uygulaması değilse uygulamanız her dosya değiştirme veya silme girişiminde kullanıcıya bir onay iletişim kutusu göstermelidir.

Uygulamanız Android 12 (API düzeyi 31) veya sonraki sürümleri hedefliyorsa kullanıcılardan uygulamanıza medya yönetimi özel izni vermelerini isteyebilirsiniz. Bu izin, uygulamanızın her dosya işlemi için kullanıcıdan izin istemesine gerek kalmadan aşağıdakileri yapmasına olanak tanır:

• createWriteRequest() kullanarak dosyaları değiştirme
• createTrashRequest() kullanarak dosyaları çöp kutusuna taşıma ve çöp kutusundan çıkarma
• createDeleteRequest() kullanarak dosyaları silin.

Bunun için aşağıdaki adımları uygulayın:

1. Uygulamanızın manifest dosyasında MANAGE_MEDIA ve READ_EXTERNAL_STORAGE izinlerini beyan edin.

   Onay iletişim kutusu göstermeden createWriteRequest() yöntemini çağırmak için ACCESS_MEDIA_LOCATION iznini de beyan edin.

2. Uygulamanızda, kullanıcılara uygulamanıza medya yönetimi erişimi vermelerinin neden iyi bir fikir olabileceğini açıklayan bir kullanıcı arayüzü gösterin.

3. ACTION_REQUEST_MANAGE_MEDIA intent işlemini çağırın. Bu işlem, kullanıcıları sistem ayarlarındaki Medya yönetim uygulamaları ekranına yönlendirir. Kullanıcılar buradan özel uygulama erişimi verebilir.

Medya mağazasına alternatif gerektiren kullanım alanları

Uygulamanız öncelikli olarak aşağıdaki rollerden birini yerine getiriyorsa MediaStore API'lerine alternatif bir çözüm kullanmayı düşünün.

Diğer dosya türleriyle çalışma

Uygulamanız, yalnızca medya içeriği barındırmayan doküman ve dosyalarla (ör. EPUB veya PDF dosya uzantısını kullanan dosyalar) çalışıyorsa dokümanları ve diğer dosyaları depolama ve bunlara erişme kılavuzunda açıklandığı gibi ACTION_OPEN_DOCUMENT intent işlemini kullanın.

Tamamlayıcı uygulamalarda dosya paylaşımı

Mesajlaşma uygulaması ve profil uygulaması gibi bir tamamlayıcı uygulama paketi sunuyorsanız content:// URI'leri kullanarak dosya paylaşımını ayarlayın. Bu iş akışını güvenlikle ilgili en iyi uygulama olarak da öneririz.

Ek kaynaklar

Medya depolama ve medyaya erişme hakkında daha fazla bilgi için aşağıdaki kaynakları inceleyin.

Örnekler

• GitHub'da bulunan MediaStore

Videolar

• Kapsamlı Depolama Alanı'na Hazırlanma (Android Dev Summit '19)