खोज…


वाक्य - विन्यास

  • FileOutputStream OpenFileInput (स्ट्रिंग नाम)
  • FileOutputStream openFileOutput (स्ट्रिंग नाम, इंट मोड)
  • फ़ाइल (फ़ाइल dir, स्ट्रिंग नाम)
  • फ़ाइल (स्ट्रिंग पथ)
  • फ़ाइल getExternalStoragePublicDirectory (स्ट्रिंग प्रकार)
  • फ़ाइल getExternalFilesDir (स्ट्रिंग प्रकार)

पैरामीटर

पैरामीटर विवरण
नाम खोलने के लिए फ़ाइल का नाम। नोट: पथ विभाजक नहीं हो सकते
मोड ऑपरेटिंग मोड। डिफ़ॉल्ट ऑपरेशन के लिए MODE_PRIVATE उपयोग करें, और एक मौजूदा फ़ाइल को जोड़ने के लिए MODE_APPEND । अन्य मोड में MODE_WORLD_READABLE और MODE_WORLD_WRITEABLE , जिन्हें API 17 में MODE_WORLD_WRITEABLE गया था।
dir में एक नई फ़ाइल बनाने के लिए फ़ाइल की निर्देशिका
पथ नई फ़ाइल का स्थान निर्दिष्ट करने के लिए पथ
प्रकार पुनर्प्राप्ति के लिए फ़ाइल निर्देशिका का प्रकार। null , या निम्न में से कोई भी हो सकता है: DIRECTORY_MUSIC , DIRECTORY_PODCASTS , DIRECTORY_RINGTONES , DIRECTORY_ALARMS , DIRECTORY_NOTIFICATIONS , DIRECTORY_PICTURES , या DIRECTORY_MOVIES

आंतरिक भंडारण का उपयोग करना

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

एक फ़ाइल के लिए पाठ लिखने के लिए

String fileName= "helloworld";
String textToWrite = "Hello, World!";
FileOutputStream fileOutputStream;

try {
  fileOutputStream = openFileOutput(fileName, Context.MODE_PRIVATE);
  fileOutputStream.write(textToWrite.getBytes());
  fileOutputStream.close();
} catch (Exception e) {
  e.printStackTrace();
}

पाठ को मौजूदा फ़ाइल में जोड़ने के लिए

उपयोग Context.MODE_APPEND के मोड पैरामीटर के लिए openFileOutput

fileOutputStream = openFileOutput(fileName, Context.MODE_APPEND);

बाहरी संग्रहण का उपयोग करना

"बाह्य" संग्रहण एक अन्य प्रकार का भंडारण है जिसका उपयोग हम उपयोगकर्ता के डिवाइस में फ़ाइलों को सहेजने के लिए कर सकते हैं। "आंतरिक" संग्रहण से इसके कुछ मुख्य अंतर हैं, जैसे:

  • यह हमेशा उपलब्ध नहीं होता है। एक हटाने योग्य माध्यम (एसडी कार्ड) के मामले में, उपयोगकर्ता बस भंडारण को हटा सकता है।
  • यह निजी नहीं है। उपयोगकर्ता (और अन्य एप्लिकेशन) की इन फ़ाइलों तक पहुंच है।
  • यदि उपयोगकर्ता ऐप को अनइंस्टॉल करता है, तो आपके द्वारा डायरेक्टरी में सेव की गई फाइलें getExternalFilesDir() से हटा दी जाएंगी।

बाहरी संग्रहण का उपयोग करने के लिए, हमें पहले उचित अनुमतियाँ प्राप्त करने की आवश्यकता है। आपको उपयोग करने की आवश्यकता होगी:

इन अनुमतियों को देने के लिए, आपको उन्हें अपने AndroidManifest.xml में पहचानना होगा

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

ध्यान दें: चूंकि वे खतरनाक अनुमतियाँ हैं यदि आप एपीआई स्तर 23 या इसके बाद के संस्करण का उपयोग कर रहे हैं, तो आपको रनटाइम में अनुमतियों का अनुरोध करना होगा।

बाह्य संग्रहण से लिखने या पढ़ने का प्रयास करने से पहले, आपको हमेशा यह देखना चाहिए कि भंडारण माध्यम उपलब्ध है।

String state = Environment.getExternalStorageState();
if (state.equals(Environment.MEDIA_MOUNTED)) {
    // Available to read and write
}
if (state.equals(Environment.MEDIA_MOUNTED) || 
        state.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
    // Available to at least read
}

बाहरी संग्रहण पर फ़ाइलें लिखते समय, आपको यह तय करना चाहिए कि क्या फ़ाइल को सार्वजनिक या निजी के रूप में मान्यता दी जानी चाहिए। जबकि इन दोनों प्रकार की फाइलें अभी भी डिवाइस पर उपयोगकर्ता और अन्य अनुप्रयोगों के लिए सुलभ हैं, उनके बीच एक महत्वपूर्ण अंतर है।

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

जब उपयोगकर्ता एप्लिकेशन को अनइंस्टॉल करता है, तो निजी फ़ाइलों को हटा दिया जाना चाहिए। इस प्रकार की फाइलें ऐप विशिष्ट होंगी, और उपयोगकर्ता या अन्य अनुप्रयोगों के लिए उपयोग की नहीं होंगी। पूर्व। आपके एप्लिकेशन द्वारा डाउनलोड / उपयोग की गई अस्थायी फाइलें।

यहां बताया गया है कि सार्वजनिक और निजी दोनों फ़ाइलों के लिए Documents निर्देशिका तक कैसे पहुँच प्राप्त करें।

जनता

// Access your app's directory in the device's Public documents directory
File docs = new File(Environment.getExternalStoragePublicDirectory(
        Environment.DIRECTORY_DOCUMENTS), "YourAppDirectory");
// Make the directory if it does not yet exist
myDocs.mkdirs();

निजी

// Access your app's Private documents directory
File file = new File(context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS), 
        "YourAppDirectory");
// Make the directory if it does not yet exist
myDocs.mkdirs();

एंड्रॉइड: इंटरनल और एक्सटर्नल स्टोरेज - टर्मिनोलॉजी क्लैरिफिकेशन

Android डेवलपर्स (मुख्य रूप से शुरुआती) आंतरिक और बाहरी भंडारण शब्दावली के बारे में उलझन में हैं। उसी के बारे में स्टाकेवरफ्लो पर बहुत सारे सवाल हैं। यह मुख्य रूप से इस तथ्य के कारण है कि Google / आधिकारिक एंड्रॉइड प्रलेखन के अनुसार शब्दावली सामान्य एंड्रॉइड ओएस उपयोगकर्ता की तुलना में काफी भिन्न है। इसलिए मुझे लगा कि इससे दस्तावेजीकरण में मदद मिलेगी।

हम क्या सोचते हैं - उपयोगकर्ता की शब्दावली (UT)

आंतरिक भंडारण (UT) बाहरी संग्रहण (UT)
फोन की इनबिल्ट इंटरनल मेमोरी हटाने योग्य सुरक्षित डिजिटल (एसडी) कार्ड या माइक्रो एसडी स्टोरेज
उदाहरण: Nexus 6P की 32 जीबी इंटरनल मेमोरी। उदाहरण: सैमसंग, सैंडिस्क, स्ट्रोंटियम, ट्रांसेंड और अन्य जैसे विक्रेताओं द्वारा दिए गए हटाने योग्य एसडी कार्ड में भंडारण स्थान

लेकिन, Android प्रलेखन / गाइड के अनुसार - Google की शब्दावली (GT)

आंतरिक भंडारण (GT):

डिफ़ॉल्ट रूप से, आंतरिक संग्रहण में सहेजी गई फ़ाइलें आपके एप्लिकेशन के लिए निजी हैं और अन्य एप्लिकेशन उन्हें एक्सेस नहीं कर सकते हैं (न ही उपयोगकर्ता कर सकते हैं)।

बाहरी संग्रहण (GT):

यह एक हटाने योग्य भंडारण मीडिया (जैसे एसडी कार्ड) या एक आंतरिक (गैर-हटाने योग्य) भंडारण हो सकता है।

बाहरी संग्रहण (GT) को दो प्रकारों में वर्गीकृत किया जा सकता है:

प्राथमिक बाह्य संग्रहण सेकेंडरी एक्सटर्नल स्टोरेज या रिमूवेबल स्टोरेज (GT)
यह फोन की इनबिल्ट इंटरनल मेमोरी (या) इंटरनल स्टोरेज (UT) के समान है यह हटाने योग्य माइक्रो एसडी कार्ड स्टोरेज (या) बाहरी स्टोरेज (UT) के समान है
उदाहरण: Nexus 6P की 32 जीबी इंटरनल मेमोरी। उदाहरण: सैमसंग, सैंडिस्क, स्ट्रोंटियम, ट्रांसेंड और अन्य जैसे विक्रेताओं द्वारा दिए गए हटाने योग्य एसडी कार्ड में भंडारण स्थान
इस प्रकार के स्टोरेज को विंडोज़ पीसी पर अपने फोन को यूएसबी केबल के माध्यम से पीसी से कनेक्ट करके और यूएसबी विकल्प अधिसूचना में कैमरा (पीटीपी) का चयन करके एक्सेस किया जा सकता है। इस प्रकार के स्टोरेज को विंडोज़ पीसी पर अपने फोन को यूएसबी केबल के माध्यम से पीसी से कनेक्ट करके और यूएसबी ऑप्शन नोटिफिकेशन में फाइल ट्रांसफर का चयन करके एक्सेस किया जा सकता है।

संक्षेप में,

बाहरी संग्रहण (GT) = आंतरिक संग्रहण (UT) और बाहरी संग्रहण (UT)

हटाने योग्य संग्रहण (GT) = बाहरी संग्रहण (UT)

आंतरिक संग्रहण (GT) का UT में कोई शब्द नहीं है।

मुझे स्पष्ट रूप से समझाएं,

इंटरनल स्टोरेज (जीटी): डिफ़ॉल्ट रूप से, आंतरिक स्टोरेज में सेव की गई फाइलें आपके एप्लिकेशन के लिए निजी होती हैं और अन्य एप्लिकेशन उन तक नहीं पहुंच सकते। आपका एप्लिकेशन उपयोगकर्ता भी फ़ाइल प्रबंधक का उपयोग करके उन्हें एक्सेस नहीं कर सकता है; फ़ाइल प्रबंधक में "छुपी हुई फ़ाइलें" विकल्प को सक्षम करने के बाद भी। इंटरनल स्टोरेज (जीटी) में फाइलों तक पहुंचने के लिए, आपको अपना एंड्रॉइड फोन रूट करना होगा। इसके अलावा, जब उपयोगकर्ता आपके एप्लिकेशन को अनइंस्टॉल करता है, तो ये फाइलें हटा दी जाती हैं / हटा दी जाती हैं।

इसलिए आंतरिक संग्रहण (GT) वह नहीं है जिसे हम Nexus 6P की 32/64 GB आंतरिक मेमोरी के रूप में सोचते हैं

आम तौर पर, आंतरिक संग्रहण (GT) स्थान होगा: /data/data/your.application.package.appname/someDirectory/

बाहरी संग्रहण (GT):

प्रत्येक एंड्रॉइड-संगत डिवाइस एक साझा "बाहरी भंडारण" का समर्थन करता है जिसका उपयोग आप फ़ाइलों को बचाने के लिए कर सकते हैं। बाहरी संग्रहण में सहेजी गई फ़ाइलें विश्व-पठनीय हैं और उपयोगकर्ता द्वारा संशोधित की जा सकती हैं जब वे कंप्यूटर पर फ़ाइलों को स्थानांतरित करने के लिए यूएसबी मास स्टोरेज को सक्षम करते हैं।

बाहरी संग्रहण (GT) स्थान: यह आपके आंतरिक संग्रहण (UT) या आपके निकाले जाने योग्य संग्रहण (GT) यानी माइक्रो SD कार्ड में कहीं भी हो सकता है। यह आपके फोन के ओईएम और एंड्रॉइड ओएस वर्जन पर भी निर्भर करता है।

बाह्य संग्रहण (GT) पर फ़ाइलों को पढ़ने या लिखने के लिए, आपके ऐप को READ_EXTERNAL_STORAGE या WRITE_EXTERNAL_STORAGE सिस्टम अनुमतियां प्राप्त करनी READ_EXTERNAL_STORAGE

उदाहरण के लिए:

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

यदि आपको फ़ाइलों को पढ़ने और लिखने दोनों की आवश्यकता है, तो आपको केवल WRITE_EXTERNAL_STORAGE अनुमति का अनुरोध करने की आवश्यकता है, क्योंकि इसमें निहित रूप से पढ़ने की आवश्यकता है।

बाहरी संग्रहण (GT) में , आप उन फ़ाइलों को भी सहेज सकते हैं जो ऐप-प्राइवेट हैं

परंतु,

जब उपयोगकर्ता आपके एप्लिकेशन को अनइंस्टॉल करता है, तो यह निर्देशिका और उसकी सभी सामग्री हटा दी जाती है।

आपको उन फ़ाइलों को सहेजने की आवश्यकता है जो बाहरी संग्रहण (GT) में ऐप-निजी हैं ?

यदि आप उन फ़ाइलों को संभाल रहे हैं जो अन्य एप्लिकेशन के लिए उपयोग नहीं किए जाते हैं (जैसे कि ग्राफिक बनावट या केवल आपके ऐप द्वारा उपयोग किए जाने वाले ध्वनि प्रभाव), तो आपको बाहरी संग्रहण पर एक निजी संग्रहण निर्देशिका का उपयोग करना चाहिए

एंड्रॉइड 4.4 के साथ शुरू करना, आपके ऐप की निजी निर्देशिकाओं में फ़ाइलों को पढ़ना या लिखना READ_EXTERNAL_STORAGE या WRITE_EXTERNAL_STORAGE अनुमतियों की आवश्यकता नहीं है। तो आप घोषित कर सकते हैं अनुमति केवल Android के निचले संस्करणों पर maxSdkVersion विशेषता जोड़कर मांगी जानी चाहिए:

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

आंतरिक संग्रहण (GT) में संग्रहीत करने के तरीके:

ये दोनों विधियाँ प्रसंग वर्ग में मौजूद हैं

File getDir (String name, int mode)

File getFilesDir () 

प्राथमिक बाह्य संग्रहण अर्थात आंतरिक संग्रहण (UT) में संग्रहीत करने के तरीके:

File getExternalStorageDirectory ()

File getExternalFilesDir (String type)

File getExternalStoragePublicDirectory (String type)

शुरुआत में, सभी ने Environment.getExternalStorageDirectory () का उपयोग किया, जिसने प्राथमिक बाहरी संग्रहण की जड़ को इंगित किया। परिणामस्वरूप, प्राथमिक बाहरी संग्रहण यादृच्छिक सामग्री से भर गया।

बाद में, इन दो विधियों को जोड़ा गया:

  1. Context वर्ग में, उन्होंने getExternalFilesDir () को जोड़ा, जो प्राथमिक बाह्य संग्रहण पर एक ऐप-विशिष्ट निर्देशिका की ओर इशारा करता है । ऐप के अनइंस्टॉल होने पर यह निर्देशिका और इसकी सामग्री हटा दी जाएगी

  2. पर्यावरण .getExternalStoragePublicDirectory () केंद्रीकृत स्थानों के लिए फोटो और फिल्मों की तरह प्रसिद्ध फ़ाइल प्रकारों को संग्रहीत करने के लिए। एप्लिकेशन को अनइंस्टॉल किए जाने पर यह निर्देशिका और इसकी सामग्री नहीं हटाई जाएगी

रिमूवेबल स्टोरेज (जीटी) यानी माइक्रो एसडी कार्ड में स्टोर करने के तरीके

एपीआई स्तर 19 से पहले, एसडी कार्ड में स्टोर करने का कोई आधिकारिक तरीका नहीं था। लेकिन, कई इसे अनौपचारिक पुस्तकालयों या एपीआई का उपयोग करके कर सकते हैं।

आधिकारिक तौर पर, एपीआई स्तर 19 (एंड्रॉइड वर्जन 4.4 - किटकैट) में एक विधि को Context क्लास में पेश किया गया था।

File[] getExternalFilesDirs (String type)

यह सभी साझा / बाहरी भंडारण उपकरणों पर एप्लिकेशन-विशिष्ट निर्देशिकाओं के लिए निरपेक्ष पथ देता है, जहां एप्लिकेशन लगातार फ़ाइलों को अपने स्वामित्व में रख सकता है। ये फ़ाइलें अनुप्रयोग के लिए आंतरिक हैं, और आमतौर पर मीडिया के रूप में उपयोगकर्ता को दिखाई नहीं देती हैं।

इसका मतलब है कि, यह दोनों प्रकार के बाह्य संग्रहण (GT) - आंतरिक मेमोरी और माइक्रो एसडी कार्ड के लिए पथ लौटाएगा। आम तौर पर दूसरा रास्ता माइक्रो एसडी कार्ड का भंडारण पथ होगा (लेकिन हमेशा नहीं)। तो आपको इस विधि के साथ कोड निष्पादित करके इसे जांचना होगा।

कोड स्निपेट के साथ उदाहरण:

मैंने खाली गतिविधि के साथ एक नया एंड्रॉइड प्रोजेक्ट बनाया, जिसमें निम्नलिखित कोड लिखा था

MainActivity.java protected void onCreate(Bundle savedInstanceState) MainActivity.java protected void onCreate(Bundle savedInstanceState) MainActivity.java protected void onCreate(Bundle savedInstanceState) विधि

    File internal_m1 = getDir("custom", 0);
    File internal_m2 = getFilesDir();

    File external_m1 =  Environment.getExternalStorageDirectory();
    
    File external_m2 =  getExternalFilesDir(null);
    File external_m2_Args = getExternalFilesDir(Environment.DIRECTORY_PICTURES);

    File external_m3 = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
    
    File[] external_AND_removable_storage_m1 = getExternalFilesDirs(null);
    File[] external_AND_removable_storage_m1_Args = getExternalFilesDirs(Environment.DIRECTORY_PICTURES);

कोड से ऊपर निष्पादित करने के बाद,

आउटपुट:

internal_m1: /data/data/your.application.package.appname/app_custom

internal_m2: /data/data/your.application.package.appname/files

external_m1: /storage/emulated/0

external_m2: /storage/emulated/0/Android/data/your.application.package.appname/files

external_m2_Args: /storage/emulated/0/Android/data/your.application.package.appname/files/Pictures

external_m3: /storage/emulated/0/Pictures

external_AND_removable_storage_m1 (first path):
/storage/emulated/0/Android/data/your.application.package.appname/files

external_AND_removable_storage_m1 (second path):    
/storage/sdcard1/Android/data/your.application.package.appname/files

 external_AND_removable_storage_m1_Args (first path):
/storage/emulated/0/Android/data/your.application.package.appname/files/Pictures

external_AND_removable_storage_m1_Args (second path): /storage/sdcard1/Android/data/your.application.package.appname/files/Pictures

नोट: मैंने अपने फोन को विंडोज पीसी से जोड़ा है; डेवलपर विकल्प, USB डिबगिंग दोनों को सक्षम किया और फिर इस कोड को चलाया। यदि आप अपना फोन कनेक्ट नहीं करते हैं ; लेकिन इसके बजाय इसे एंड्रॉइड एमुलेटर पर चलाएं, आपका आउटपुट भिन्न हो सकता है। मेरा फोन मॉडल कूलपैड नोट 3 है - एंड्रॉइड 5.1 पर चल रहा है

मेरे फ़ोन पर संग्रहण स्थान:

माइक्रो एसडी भंडारण स्थान : /storage/sdcard1

आंतरिक संग्रहण (UT) स्थान : /storage/sdcard0

ध्यान दें कि /sdcard और /storage/emulated/0 भी Internal Storage (UT) की ओर इशारा करता है। लेकिन ये /storage/sdcard0

एंड्रॉइड में विभिन्न स्टोरेज पथों को स्पष्ट रूप से समझने के लिए, कृपया इस उत्तर के माध्यम से जाएं

डिस्क्लेमर: ऊपर वर्णित सभी स्टोरेज पथ मेरे फोन पर पथ हैं। आपकी फ़ाइलें समान संग्रहण पथ पर संग्रहीत नहीं की जा सकती हैं। क्योंकि, आपके विक्रेता, निर्माता और Android OS के विभिन्न संस्करणों के आधार पर अन्य मोबाइल फोन पर स्टोरेज लोकेशन / पाथ अलग-अलग हो सकते हैं।

एसडी कार्ड पर डेटाबेस सहेजें (एसडी पर बैकअप डीबी)

    public static Boolean ExportDB(String DATABASE_NAME , String packageName , String folderName){
    //DATABASE_NAME including ".db" at the end like "mayApp.db"
    String DBName = DATABASE_NAME.substring(0, DATABASE_NAME.length() - 3);
    File data = Environment.getDataDirectory();
    FileChannel source=null;
    FileChannel destination=null;
    String currentDBPath = "/data/"+ packageName +"/databases/"+DATABASE_NAME; // getting app db path

    File sd = Environment.getExternalStorageDirectory(); // getting phone SD card path
    String backupPath = sd.getAbsolutePath() + folderName; // if you want to set backup in specific folder name
        /* be careful , foldername must initial like this : "/myFolder" . dont forget "/" at begin of folder name
            you could define foldername like this : "/myOutterFolder/MyInnerFolder" and so on ...
        */
    File dir = new File(backupPath);
    if(!dir.exists()) // if there was no folder at this path , it create it .
    {
        dir.mkdirs();
    }

    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss");
    Date date = new Date();
        /* use date including file name for arrange them and preventing to make file with the same*/
    File currentDB = new File(data, currentDBPath);
    File backupDB = new File(backupPath, DBName +"("+ dateFormat.format(date)+").db");
    try {
        if (currentDB.exists() && !backupDB.exists()) {
            source = new FileInputStream(currentDB).getChannel();
            destination = new FileOutputStream(backupDB).getChannel();
            destination.transferFrom(source, 0, source.size());
            source.close();
            destination.close();
            return true;
        }
        return false;
    } catch(IOException e) {
        e.printStackTrace();
        return false;
    }
}

इस तरीके को इस तरह से कॉल करें:

ExportDB ( "myDB.db", "com.example.exam" "/ MyFolder");

फ़ेच डिवाइस निर्देशिका:

डिवाइस निर्देशिका को पढ़ने / लाने के लिए पहले संग्रहण अनुमति जोड़ें।

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

मॉडल वर्ग बनाएं

//create one directory model class
//to store directory title and type in list

public class DirectoryModel {
    String dirName;
    int dirType; // set 1 or 0, where 0 for directory and 1 for file.

    public int getDirType() {
        return dirType;
    }

    public void setDirType(int dirType) {
        this.dirType = dirType;
    }

    public String getDirName() {
        return dirName;
    }

    public void setDirName(String dirName) {
        this.dirName = dirName;
    }
}

निर्देशिका डेटा जोड़ने के लिए निर्देशिका मॉडल का उपयोग करके सूची बनाएं।

//define list to show directory

List<DirectoryModel> rootDir = new ArrayList<>();

निम्नलिखित विधि का उपयोग करके निर्देशिका प्राप्त करें।

//to fetch device directory

private void getDirectory(String currDir) { // pass device root directory
        File f = new File(currDir);
        File[] files = f.listFiles();
        if (files != null) {
            if (files.length > 0) {
                rootDir.clear();
                for (File inFile : files) {
                    if (inFile.isDirectory()) { //return true if it's directory
                        // is directory
                        DirectoryModel dir = new DirectoryModel();
                        dir.setDirName(inFile.toString().replace("/storage/emulated/0", ""));
                        dir.setDirType(0); // set 0 for directory
                        rootDir.add(dir);
                    } else if (inFile.isFile()) { // return true if it's file
                        //is file
                        DirectoryModel dir = new DirectoryModel();
                        dir.setDirName(inFile.toString().replace("/storage/emulated/0", ""));
                        dir.setDirType(1); // set 1 for file
                        rootDir.add(dir);
                    }
                }
            }
            printDirectoryList();
        }
    }

लॉग में निर्देशिका सूची मुद्रित करें।

//print directory list in logs

private void printDirectoryList() {
    for (int i = 0; i < rootDir.size(); i++) {
        Log.e(TAG, "printDirectoryLogs: " + rootDir.get(i).toString());
    }
}

प्रयोग

//to Fetch Directory Call function with root directory.

String rootPath = Environment.getExternalStorageDirectory().toString(); // return ==>  /storage/emulated/0/
getDirectory(rootPath );

विशिष्ट निर्देशिका की आंतरिक फ़ाइलों / फ़ोल्डर को लाने के लिए, तर्क बदलने के लिए उसी विधि का उपयोग करें, तर्क में वर्तमान चयनित पथ को पास करें और उसी के लिए प्रतिक्रिया को संभालें।

फाइल एक्सटेंशन पाने के लिए:

private String getExtension(String filename) {

    String filenameArray[] = filename.split("\\.");
    String extension = filenameArray[filenameArray.length - 1];
    Log.d(TAG, "getExtension: " + extension);

    return extension;
}


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow