ऐप्लिकेशन के लिए खास तौर पर बनी फ़ाइलें ऐक्सेस करना

कई मामलों में, आपका ऐप्लिकेशन ऐसी फ़ाइलें बना देता है जिन्हें दूसरे ऐप्लिकेशन को ऐक्सेस करने की ज़रूरत नहीं होती या जिन्हें ऐक्सेस नहीं करना चाहिए. इस तरह की ऐप्लिकेशन की खास फ़ाइलों को सेव करने के लिए सिस्टम इन जगहों की जानकारी देता है:

  • डिवाइस का स्टोरेज डायरेक्ट्री: इन डायरेक्ट्री में, हमेशा सेव रहने वाली फ़ाइलों को स्टोर करने के लिए एक जगह और कैश मेमोरी का डेटा स्टोर करने के लिए एक जगह होती है. सिस्टम, दूसरे ऐप्लिकेशन को इन जगहों को ऐक्सेस करने से रोकता है. साथ ही, Android 10 (एपीआई लेवल 29) और इसके बाद वाले वर्शन पर, इन जगहों की जानकारी एन्क्रिप्ट (सुरक्षित) की जाती है. इन विशेषताओं की वजह से, इन जगहों पर संवेदनशील डेटा सेव करना अच्छा होता है. इस डेटा को सिर्फ़ आपका ऐप्लिकेशन ऐक्सेस कर सकता है.

  • बाहरी स्टोरेज डायरेक्ट्री: इन डायरेक्ट्री में, हमेशा सेव रहने वाली फ़ाइलों को सेव करने के लिए एक खास जगह और कैश मेमोरी डेटा को सेव करने के लिए एक और जगह शामिल होती है. अगर किसी ऐप्लिकेशन के पास सही अनुमतियां हैं, तो वह इन डायरेक्ट्री को ऐक्सेस कर सकता है. हालांकि, इन डायरेक्ट्री में सेव की गई फ़ाइलों का इस्तेमाल सिर्फ़ आपका ऐप्लिकेशन कर सकता है. अगर आपको ऐसी फ़ाइलें बनानी हैं जिन्हें दूसरे ऐप्लिकेशन ऐक्सेस कर सकें, तो आपके ऐप्लिकेशन को इन फ़ाइलों को बाहरी स्टोरेज के शेयर किए गए स्टोरेज में सेव करना चाहिए.

जब उपयोगकर्ता आपका ऐप्लिकेशन अनइंस्टॉल करता है, तो ऐप्लिकेशन के लिए खास तौर पर बने स्टोरेज में सेव की गई फ़ाइलें हटा दी जाती हैं. इस व्यवहार की वजह से, आपको इस स्टोरेज का इस्तेमाल ऐसी कोई चीज़ सेव करने के लिए नहीं करना चाहिए जिसकी उपयोगकर्ता आपके ऐप्लिकेशन से स्वतंत्र रूप से काम करना चाहे

नीचे दिए गए सेक्शन में, ऐप्लिकेशन के हिसाब से बनी डायरेक्ट्री में फ़ाइलों को सेव और ऐक्सेस करने का तरीका बताया गया है.

डिवाइस के स्टोरेज से ऐक्सेस करना

हर ऐप्लिकेशन के लिए, सिस्टम डिवाइस के स्टोरेज में डायरेक्ट्री उपलब्ध कराता है. यहां ऐप्लिकेशन में मौजूद फ़ाइलों को व्यवस्थित किया जा सकता है. एक डायरेक्ट्री को आपके ऐप्लिकेशन की सेव की गई फ़ाइलों के लिए डिज़ाइन किया गया है. वहीं, दूसरी डायरेक्ट्री में आपके ऐप्लिकेशन की कैश मेमोरी में सेव की गई फ़ाइलें होती हैं. इन डायरेक्ट्री में मौजूद फ़ाइलों को पढ़ने और उनमें बदलाव करने के लिए, आपके ऐप्लिकेशन को सिस्टम से अनुमति लेने की ज़रूरत नहीं होती.

दूसरे ऐप्लिकेशन, डिवाइस के स्टोरेज में सेव की गई फ़ाइलों को ऐक्सेस नहीं कर सकते. इससे मोबाइल स्टोरेज ऐसे ऐप्लिकेशन डेटा के लिए एक अच्छी जगह बन जाता है जिसे दूसरे ऐप्लिकेशन को ऐक्सेस नहीं करना चाहिए.

हालांकि, ध्यान रखें कि ये डायरेक्ट्री छोटी होती हैं. खास तौर पर ऐप्लिकेशन के लिए बनाई गई फ़ाइलों को डिवाइस के स्टोरेज में लिखने से पहले, आपके ऐप्लिकेशन को डिवाइस पर मौजूद खाली जगह के बारे में क्वेरी करनी चाहिए.

स्थायी फ़ाइलें ऐक्सेस करें

आपके ऐप्लिकेशन की सामान्य और हमेशा मौजूद फ़ाइलें, एक डायरेक्ट्री में रहती हैं. इसे किसी कॉन्टेक्स्ट ऑब्जेक्ट की filesDir प्रॉपर्टी का इस्तेमाल करके ऐक्सेस किया जा सकता है. इस फ़्रेमवर्क में, आपको इस डायरेक्ट्री में फ़ाइलों को ऐक्सेस और स्टोर करने में मदद करने के लिए कई तरीके मिलते हैं.

फ़ाइलें ऐक्सेस और सेव करना

फ़ाइलों को ऐक्सेस और सेव करने के लिए, File एपीआई का इस्तेमाल किया जा सकता है.

अपने ऐप्लिकेशन की परफ़ॉर्मेंस को बनाए रखने के लिए, एक ही फ़ाइल को कई बार खोलने और बंद करने से बचें.

नीचे दिए गए कोड स्निपेट में, File एपीआई को इस्तेमाल करने का तरीका बताया गया है:

Kotlin

val file = File(context.filesDir, filename)

Java

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

स्ट्रीम का इस्तेमाल करके फ़ाइल सेव करना

File एपीआई का इस्तेमाल करने के बजाय, openFileOutput() को कॉल करके FileOutputStream पाया जा सकता है. यह filesDir डायरेक्ट्री में मौजूद फ़ाइल में लिखता है.

नीचे दिए गए कोड स्निपेट में, किसी फ़ाइल में टेक्स्ट लिखने का तरीका बताया गया है:

Kotlin

val filename = "myfile"
val fileContents = "Hello world!"
context.openFileOutput(filename, Context.MODE_PRIVATE).use {
        it.write(fileContents.toByteArray())
}

Java

String filename = "myfile";
String fileContents = "Hello world!";
try (FileOutputStream fos = context.openFileOutput(filename, Context.MODE_PRIVATE)) {
    fos.write(fileContents.toByteArray());
}

डिवाइस के स्टोरेज में मौजूद इस डायरेक्ट्री में सेव की गई फ़ाइलों को अन्य ऐप्लिकेशन को ऐक्सेस करने की अनुमति देने के लिए, FLAG_GRANT_READ_URI_PERMISSION एट्रिब्यूट के साथ FileProvider का इस्तेमाल करें.

स्ट्रीम का इस्तेमाल करके फ़ाइल ऐक्सेस करना

किसी फ़ाइल को स्ट्रीम के तौर पर पढ़ने के लिए, openFileInput() का इस्तेमाल करें:

Kotlin

context.openFileInput(filename).bufferedReader().useLines { lines ->
    lines.fold("") { some, text ->
        "$some\n$text"
    }
}

Java

FileInputStream fis = context.openFileInput(filename);
InputStreamReader inputStreamReader =
        new InputStreamReader(fis, StandardCharsets.UTF_8);
StringBuilder stringBuilder = new StringBuilder();
try (BufferedReader reader = new BufferedReader(inputStreamReader)) {
    String line = reader.readLine();
    while (line != null) {
        stringBuilder.append(line).append('\n');
        line = reader.readLine();
    }
} catch (IOException e) {
    // Error occurred when opening raw file for reading.
} finally {
    String contents = stringBuilder.toString();
}

फ़ाइलों की सूची देखना

filesDir डायरेक्ट्री में मौजूद सभी फ़ाइलों के नामों वाला कलेक्शन पाने के लिए, fileList() को कॉल करें. इस बारे में यहां दिए गए कोड स्निपेट में बताया गया है:

Kotlin

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

Java

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

नेस्ट की गई डायरेक्ट्री बनाना

नेस्ट की गई डायरेक्ट्री भी बनाई जा सकती हैं या कोई अंदरूनी डायरेक्ट्री खोली जा सकती है. इसके लिए, Kotlin पर आधारित कोड में getDir() को कॉल करें या Java पर आधारित कोड में File कंस्ट्रक्टर में रूट डायरेक्ट्री और नई डायरेक्ट्री का नाम पास करें:

Kotlin

context.getDir(dirName, Context.MODE_PRIVATE)

Java

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

कैश मेमोरी फ़ाइलें बनाना

अगर आपको संवेदनशील जानकारी को सिर्फ़ कुछ समय के लिए सेव करना है, तो डेटा सेव करने के लिए ऐप्लिकेशन की तय की गई कैश मेमोरी वाली डायरेक्ट्री का इस्तेमाल करें. ऐप्लिकेशन के लिए तय किए गए सभी स्टोरेज की तरह ही, इस डायरेक्ट्री में सेव की गई फ़ाइलें, उपयोगकर्ता के आपके ऐप्लिकेशन को अनइंस्टॉल करने पर हटा दी जाती हैं. हालांकि, इस डायरेक्ट्री में मौजूद फ़ाइलों को पहले भी हटाया जा सकता है.

कैश मेमोरी में सेव की जाने वाली फ़ाइल बनाने के लिए, File.createTempFile() को कॉल करें:

Kotlin

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

Java

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

आपका ऐप्लिकेशन, किसी कॉन्टेक्स्ट ऑब्जेक्ट की cacheDir प्रॉपर्टी और File एपीआई का इस्तेमाल करके, इस डायरेक्ट्री में मौजूद फ़ाइल को ऐक्सेस करता है:

Kotlin

val cacheFile = File(context.cacheDir, filename)

Java

File cacheFile = new File(context.getCacheDir(), filename);

कैश फ़ाइलें हटाना

भले ही Android कभी-कभी कैश फ़ाइलों को अपने-आप मिटा देता है, लेकिन आपको इन फ़ाइलों को हटाने के लिए सिस्टम पर भरोसा नहीं करना चाहिए. आपको ऐप्लिकेशन की कैश मेमोरी में सेव की गई फ़ाइलों को हमेशा डिवाइस के स्टोरेज में रखना चाहिए.

डिवाइस के स्टोरेज में कैश डायरेक्ट्री से कोई फ़ाइल हटाने के लिए, इनमें से किसी एक तरीके का इस्तेमाल करें:

  • File ऑब्जेक्ट पर delete() तरीका, जो फ़ाइल को दिखाता है:

    Kotlin

    cacheFile.delete()

    Java

    cacheFile.delete();

  • ऐप्लिकेशन के कॉन्टेक्स्ट का तरीका, deleteFile() फ़ाइल का नाम डालना:

    Kotlin

    context.deleteFile(cacheFileName)

    Java

    context.deleteFile(cacheFileName);

बाहरी स्टोरेज से ऐक्सेस करना

अगर डिवाइस के स्टोरेज में, ऐप्लिकेशन के लिए बनी फ़ाइलों को सेव करने के लिए ज़रूरत के मुताबिक जगह नहीं है, तो डिवाइस के बाहरी स्टोरेज का इस्तेमाल करें. यह सिस्टम, बाहरी स्टोरेज में डायरेक्ट्री उपलब्ध कराता है. यहां ऐप्लिकेशन, ऐसी फ़ाइलों को व्यवस्थित कर सकता है जो सिर्फ़ आपके ऐप्लिकेशन में उपयोगकर्ता के लिए काम की हैं. एक डायरेक्ट्री, आपके ऐप्लिकेशन की हमेशा मौजूद रहने वाली फ़ाइलों के लिए डिज़ाइन की गई है. वहीं, दूसरी डायरेक्ट्री में आपके ऐप्लिकेशन की कैश मेमोरी में सेव की गई फ़ाइलें होती हैं.

Android 4.4 (एपीआई लेवल 19) या उसके बाद के वर्शन पर, आपके ऐप्लिकेशन को बाहरी स्टोरेज में ऐप्लिकेशन से जुड़ी डायरेक्ट्री ऐक्सेस करने के लिए, स्टोरेज से जुड़ी किसी भी अनुमति का अनुरोध करने की ज़रूरत नहीं है. ऐप्लिकेशन को अनइंस्टॉल करने पर, इन डायरेक्ट्री में सेव की गई फ़ाइलें हटा दी जाती हैं.

Android 9 (एपीआई लेवल 28) या इससे पहले के वर्शन वाले डिवाइसों पर, आपका ऐप्लिकेशन दूसरे ऐप्लिकेशन की उन खास फ़ाइलों को ऐक्सेस कर सकता है जो ऐप्लिकेशन से जुड़ी हैं. हालांकि, इसके लिए ज़रूरी है कि आपके ऐप्लिकेशन के पास स्टोरेज के लिए ज़रूरी अनुमतियां हों. उपयोगकर्ताओं को अपनी फ़ाइलों पर ज़्यादा कंट्रोल देने और फ़ाइलों को व्यवस्थित रखने के लिए, Android 10 (एपीआई लेवल 29) और उसके बाद के वर्शन को टारगेट करने वाले ऐप्लिकेशन को डिफ़ॉल्ट रूप से, बाहरी स्टोरेज या स्कोप की गई स्टोरेज का ऐक्सेस दिया जाता है. स्कोप वाली मेमोरी की सुविधा चालू होने पर, ऐप्लिकेशन खास तौर पर उन डायरेक्ट्री को ऐक्सेस नहीं कर सकते जो दूसरे ऐप्लिकेशन से जुड़ी हैं.

पुष्टि करना कि स्टोरेज उपलब्ध है

बाहरी स्टोरेज, किसी फ़िज़िकल वॉल्यूम में होता है जिसे उपयोगकर्ता कभी भी हटा सकता है. इसलिए, बाहरी स्टोरेज में ऐप्लिकेशन से जुड़ा डेटा पढ़ने या उसमें ऐप्लिकेशन से जुड़ा डेटा लिखने से पहले, पुष्टि करें कि वॉल्यूम को ऐक्सेस किया जा सकता है.

Environment.getExternalStorageState() को कॉल करके, वॉल्यूम की स्थिति के बारे में क्वेरी की जा सकती है. अगर रिटर्न की गई स्थिति MEDIA_MOUNTED है, तो बाहरी स्टोरेज में ऐप्लिकेशन के लिए खास तौर पर दी गई फ़ाइलों को पढ़ा और उनमें बदलाव किया जा सकता है. अगर MEDIA_MOUNTED_READ_ONLY है, तो इन फ़ाइलों को सिर्फ़ पढ़ा जा सकता है.

उदाहरण के लिए, स्टोरेज की उपलब्धता का पता लगाने के लिए, ये तरीके काम के हैं:

Kotlin

// Checks if a volume containing external storage is available
// for read and write.
fun isExternalStorageWritable(): Boolean {
    return Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED
}

// Checks if a volume containing external storage is available to at least read.
fun isExternalStorageReadable(): Boolean {
     return Environment.getExternalStorageState() in
        setOf(Environment.MEDIA_MOUNTED, Environment.MEDIA_MOUNTED_READ_ONLY)
}

Java

// Checks if a volume containing external storage is available
// for read and write.
private boolean isExternalStorageWritable() {
    return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
}

// Checks if a volume containing external storage is available to at least read.
private boolean isExternalStorageReadable() {
     return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) ||
            Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY);
}

जिन डिवाइसों में बाहरी स्टोरेज की सुविधा नहीं है उन पर, बाहरी स्टोरेज की उपलब्धता की जांच करने के लिए वर्चुअल वॉल्यूम चालू करने के लिए, नीचे दिए गए निर्देश का पालन करें:

adb shell sm set-virtual-disk true

स्टोरेज की जगह चुनना

कभी-कभी, ऐसा डिवाइस जो अपनी इंटरनल मेमोरी का एक सेक्शन, बाहरी स्टोरेज के तौर पर इस्तेमाल करता है, उसमें एसडी कार्ड स्लॉट भी होता है. इसका मतलब है कि डिवाइस में कई फ़िज़िकल वॉल्यूम हैं, जिनमें बाहरी स्टोरेज हो सकता है. इसलिए, आपको यह चुनना होगा कि ऐप्लिकेशन के लिए खास तौर पर दिए गए स्टोरेज के लिए, किस वॉल्यूम का इस्तेमाल करना है.

अलग-अलग जगहों को ऐक्सेस करने के लिए, ContextCompat.getExternalFilesDirs() को कॉल करें. कोड स्निपेट में दिखाए गए तरीके के मुताबिक, दिखाए गए कलेक्शन के पहले एलिमेंट को मुख्य बाहरी स्टोरेज वॉल्यूम माना जाता है. जब तक यह वॉल्यूम पूरा न हो जाए या उपलब्ध न हो, तब तक इसका इस्तेमाल करें.

Kotlin

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

Java

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

परसिस्टेंट फ़ाइलें ऐक्सेस करना

बाहरी स्टोरेज में मौजूद, ऐप्लिकेशन के लिए खास तौर पर सेव की गई फ़ाइलों को ऐक्सेस करने के लिए, getExternalFilesDir() बोलें.

अपने ऐप्लिकेशन की परफ़ॉर्मेंस को बनाए रखने के लिए, एक ही फ़ाइल को कई बार खोलने और बंद करने से बचें.

नीचे दिए गए कोड स्निपेट में, getExternalFilesDir() को कॉल करने का तरीका बताया गया है:

Kotlin

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

Java

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

कैश मेमोरी फ़ाइलें बनाना

बाहरी स्टोरेज में मौजूद कैश मेमोरी में, किसी ऐप्लिकेशन की फ़ाइल जोड़ने के लिए, externalCacheDir का रेफ़रंस पाएं:

Kotlin

val externalCacheFile = File(context.externalCacheDir, filename)

Java

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

कैश मेमोरी में सेव की गई फ़ाइलें हटाना

बाहरी कैश डायरेक्ट्री से किसी फ़ाइल को हटाने के लिए, फ़ाइल को दिखाने वाले File ऑब्जेक्ट पर delete() तरीके का इस्तेमाल करें:

Kotlin

externalCacheFile.delete()

Java

externalCacheFile.delete();

मीडिया कॉन्टेंट

अगर आपका ऐप्लिकेशन ऐसी मीडिया फ़ाइलों के साथ काम करता है जो सिर्फ़ आपके ऐप्लिकेशन में उपयोगकर्ता के लिए काम की हैं, तो उन्हें बाहरी स्टोरेज में ऐप्लिकेशन के हिसाब से बनी डायरेक्ट्री में सेव करना सबसे अच्छा होता है. इस बारे में नीचे दिए गए कोड स्निपेट में बताया गया है:

Kotlin

fun getAppSpecificAlbumStorageDir(context: Context, albumName: String): File? {
    // Get the pictures directory that's inside the app-specific directory on
    // external storage.
    val file = File(context.getExternalFilesDir(
            Environment.DIRECTORY_PICTURES), albumName)
    if (!file?.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created")
    }
    return file
}

Java

@Nullable
File getAppSpecificAlbumStorageDir(Context context, String albumName) {
    // Get the pictures directory that's inside the app-specific directory on
    // external storage.
    File file = new File(context.getExternalFilesDir(
            Environment.DIRECTORY_PICTURES), albumName);
    if (file == null || !file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}

यह ज़रूरी है कि आप DIRECTORY_PICTURES जैसी एपीआई कॉन्स्टेंट से दी गई डायरेक्ट्री के नामों का इस्तेमाल करें. डायरेक्ट्री के इन नामों से यह पक्का होता है कि सिस्टम, फ़ाइलों को सही तरीके से मैनेज करता है. अगर पहले से तय की गई सब-डायरेक्ट्री के नाम में से कोई भी नाम आपकी फ़ाइलों के हिसाब से नहीं है, तो null को getExternalFilesDir() में पास किया जा सकता है. इससे एक्सटर्नल स्टोरेज में ऐप्लिकेशन के लिए बनी रूट डायरेक्ट्री दिखती है.

क्वेरी खाली स्थान

कई उपयोगकर्ताओं के डिवाइसों में ज़्यादा स्टोरेज नहीं होता. इसलिए, आपके ऐप्लिकेशन को स्टोरेज का इस्तेमाल सोच-समझकर करना चाहिए.

अगर आपको पहले से पता है कि कितना डेटा सेव किया जा रहा है, तो getAllocatableBytes() को कॉल करके यह पता लगाया जा सकता है कि डिवाइस आपके ऐप्लिकेशन के लिए कितना स्टोरेज उपलब्ध करा सकता है. getAllocatableBytes() की रिटर्न वैल्यू, डिवाइस में मौजूदा खाली जगह से ज़्यादा हो सकती है. ऐसा इसलिए होता है, क्योंकि सिस्टम ने उन फ़ाइलों की पहचान कर ली है जिन्हें अन्य ऐप्लिकेशन की कैश मेमोरी डायरेक्ट्री से हटाया जा सकता है.

अगर आपके ऐप्लिकेशन के डेटा को सेव करने के लिए ज़रूरी जगह है, तो allocateBytes() को कॉल करें. ऐसा न करने पर, आपका ऐप्लिकेशन उपयोगकर्ता से डिवाइस से कुछ फ़ाइलें हटाने या सभी कैश मेमोरी फ़ाइलें हटाने का अनुरोध कर सकता है.

नीचे दिया गया कोड स्निपेट यह दिखाता है कि आपका ऐप्लिकेशन डिवाइस पर खाली जगह के लिए क्वेरी कैसे कर सकता है:

Kotlin

// App needs 10 MB within internal storage.
const val NUM_BYTES_NEEDED_FOR_MY_APP = 1024 * 1024 * 10L;

val storageManager = applicationContext.getSystemService<StorageManager>()!!
val appSpecificInternalDirUuid: UUID = storageManager.getUuidForPath(filesDir)
val availableBytes: Long =
        storageManager.getAllocatableBytes(appSpecificInternalDirUuid)
if (availableBytes >= NUM_BYTES_NEEDED_FOR_MY_APP) {
    storageManager.allocateBytes(
        appSpecificInternalDirUuid, NUM_BYTES_NEEDED_FOR_MY_APP)
} else {
    val storageIntent = Intent().apply {
        // To request that the user remove all app cache files instead, set
        // "action" to ACTION_CLEAR_APP_CACHE.
        action = ACTION_MANAGE_STORAGE
    }
}

Java

// App needs 10 MB within internal storage.
private static final long NUM_BYTES_NEEDED_FOR_MY_APP = 1024 * 1024 * 10L;

StorageManager storageManager =
        getApplicationContext().getSystemService(StorageManager.class);
UUID appSpecificInternalDirUuid = storageManager.getUuidForPath(getFilesDir());
long availableBytes =
        storageManager.getAllocatableBytes(appSpecificInternalDirUuid);
if (availableBytes >= NUM_BYTES_NEEDED_FOR_MY_APP) {
    storageManager.allocateBytes(
            appSpecificInternalDirUuid, NUM_BYTES_NEEDED_FOR_MY_APP);
} else {
    // To request that the user remove all app cache files instead, set
    // "action" to ACTION_CLEAR_APP_CACHE.
    Intent storageIntent = new Intent();
    storageIntent.setAction(ACTION_MANAGE_STORAGE);
}

स्टोरेज मैनेज करने की गतिविधि बनाना

आपका ऐप्लिकेशन, एक कस्टम गतिविधि का एलान कर सकता है और उसे बना सकता है. लॉन्च होने के बाद, उपयोगकर्ता इस डेटा को मैनेज कर सकता है, जिसे आपके ऐप्लिकेशन ने उपयोगकर्ता के डिवाइस पर सेव किया है. मेनिफ़ेस्ट फ़ाइल में, android:manageSpaceActivity एट्रिब्यूट का इस्तेमाल करके, पसंद के मुताबिक "स्पेस मैनेज करें" गतिविधि का एलान किया जाता है. फ़ाइल मैनेजर वाले ऐप्लिकेशन, इस गतिविधि को शुरू कर सकते हैं. भले ही, आपका ऐप्लिकेशन इस गतिविधि को एक्सपोर्ट न करता हो. इसका मतलब है कि जब आपकी गतिविधि, गतिविधि को android:exportedfalse पर सेट करती है, तब भी ऐसा हो सकता है.

उपयोगकर्ता से डिवाइस की कुछ फ़ाइलें हटाने के लिए कहें

उपयोगकर्ता से डिवाइस पर मौजूद फ़ाइलों को हटाने का अनुरोध करने के लिए, ऐसा इंटेंट ट्रिगर करें जिसमें ACTION_MANAGE_STORAGE कार्रवाई शामिल हो. यह इंटेंट, उपयोगकर्ता को एक प्रॉम्प्ट दिखाता है. अगर आप चाहें, तो इस प्रॉम्प्ट में डिवाइस में मौजूद खाली जगह की जानकारी दिख सकती है. उपयोगकर्ता के हिसाब से यह जानकारी दिखाने के लिए, इस हिसाब के नतीजे का इस्तेमाल करें:

StorageStatsManager.getFreeBytes() / StorageStatsManager.getTotalBytes()

उपयोगकर्ता से सभी कैश मेमोरी फ़ाइलें हटाने के लिए कहना

इसके अलावा, उपयोगकर्ता से डिवाइस पर मौजूद सभी ऐप्लिकेशन की कैश मेमोरी फ़ाइलें मिटाने का अनुरोध किया जा सकता है. ऐसा करने के लिए, किसी ऐसे इंटेंट को ट्रिगर करें जिसमें ACTION_CLEAR_APP_CACHE इंटेंट ऐक्शन शामिल हो.

अन्य संसाधन

डिवाइस के स्टोरेज में फ़ाइलें सेव करने के बारे में ज़्यादा जानने के लिए, यहां दिए गए संसाधन देखें.

वीडियो