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

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

  • डिवाइस का स्टोरेज डायरेक्ट्री: इन डायरेक्ट्री में, हमेशा सेव रहने वाली फ़ाइलों को स्टोर करने के लिए एक खास जगह और कैश मेमोरी का डेटा स्टोर करने के लिए एक और जगह होती है. सिस्टम, अन्य ऐप्लिकेशन को इन जगहों को ऐक्सेस करने से रोकता है. साथ ही, 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:exported को false पर सेट करती है.

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

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

StorageStatsManager.getFreeBytes() / StorageStatsManager.getTotalBytes()

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

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

अन्य संसाधन

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

वीडियो