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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

यह कोड स्निपेट, File API को इस्तेमाल करने का तरीका बताता है:

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

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

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

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:exported को false पर सेट करती है.

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

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

StorageStatsManager.getFreeBytes() / StorageStatsManager.getTotalBytes()

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

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

अन्य संसाधन

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

वीडियो