क्या एंड्रॉइड एसडीके के माध्यम से एंड्रॉइड डिवाइस (एसडी कार्ड पर नहीं) पर मुफ्त मेमोरी की मात्रा प्राप्त करना संभव है?आंतरिक मेमोरी पर मुफ्त स्थान प्राप्त करें
यदि हां, तो कैसे?
क्या एंड्रॉइड एसडीके के माध्यम से एंड्रॉइड डिवाइस (एसडी कार्ड पर नहीं) पर मुफ्त मेमोरी की मात्रा प्राप्त करना संभव है?आंतरिक मेमोरी पर मुफ्त स्थान प्राप्त करें
यदि हां, तो कैसे?
this पोस्ट आपके प्रश्न के लिए उपयुक्त हो सकता है।
भी this thread जांचें। एसओ पर यहां बहुत सारी जानकारी है।
थोड़ा googled और यहाँ समाधान (android git में पाया)
File path = Environment.getDataDirectory();
StatFs stat = new StatFs(path.getPath());
long blockSize = stat.getBlockSize();
long availableBlocks = stat.getAvailableBlocks();
return Formatter.formatFileSize(this, availableBlocks * blockSize);
मुझे विश्वास है कि क्लैंप असल में वास्तविक भंडारण के बारे में पूछना, स्मृति उपयोग नहीं (मैं इसे एसडी कार्ड के उल्लेख से बता रहा हूं)। – kcoppock
धन्यवाद, हाँ मैं स्टोरेज मेमोरी के बारे में बात कर रहा हूं। – clamp
अच्छा जवाब। जो मैं देख सकता हूं, उससे कोई सख्त चेतावनी नहीं मिलती है, जिससे इसे मुख्य धागा सुरक्षित बना दिया जाता है। मैं सख्त मोड चेतावनी की आधा उम्मीद कर रहा था क्योंकि यह फाइल सिस्टम से संबंधित है। – Mattias
ऐसा लगता है कि StatFs
वर्ग हो सकता है कि तुम क्या उपयोग करने की आवश्यकता है। मुझे यकीन नहीं है कि डिवाइस के रूट को कौन सा पथ माना जाएगा, लेकिन मेरा मानना है कि परिणाम निर्देशिका के बावजूद समान होगा, जब तक यह आंतरिक भंडारण का हिस्सा न हो। कुछ इस तरह काम कर सकते हैं:
StatFs stats = new StatFs("/data");
int availableBlocks = stats.getAvailableBlocks();
int blockSizeInBytes = stats.getBlockSize();
int freeSpaceInBytes = availableBlocks * blockSizeInBytes;
हैं और कुछ नहीं, StatFs वर्ग आप देखने के लिए जहां पर एक अच्छी शुरुआत देना चाहिए।
कूल! मैंने इसे "/" के लिए प्राप्त करने का प्रयास किया जो काम नहीं करता था। आंतरिक स्मृति के लिए "/ डेटा" का उपयोग करना। –
उन डिवाइसों पर जहां आंतरिक मेमोरी आकार बहुत बड़ा है, यह काम नहीं करता है क्योंकि int मान बहुत छोटा है। उदाहरण के लिए मोटोरोला xum पर यह काम नहीं करता है। आप कुछ इस तरह उपयोग करने के लिए है:
int freeSpaceInKilobytes = availableBlocks * (blockSizeInBytes/1024);
या लंबे प्रकार का उपयोग करें, int नहीं। –
/*************************************************************************************************
Returns size in bytes.
If you need calculate external memory, change this:
StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());
to this:
StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath());
**************************************************************************************************/
public long TotalMemory()
{
StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());
long Total = ((long) statFs.getBlockCount() * (long) statFs.getBlockSize());
return Total;
}
public long FreeMemory()
{
StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());
long Free = (statFs.getAvailableBlocks() * (long) statFs.getBlockSize());
return Free;
}
public long BusyMemory()
{
StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());
long Total = ((long) statFs.getBlockCount() * (long) statFs.getBlockSize());
long Free = (statFs.getAvailableBlocks() * (long) statFs.getBlockSize());
long Busy = Total - Free;
return Busy;
}
मानव पठनीय प्रारूप करने के लिए बाइट्स परिवर्तित (जैसे 1 एमबी, 1 जीबी)
public static String floatForm (double d)
{
return new DecimalFormat("#.##").format(d);
}
public static String bytesToHuman (long size)
{
long Kb = 1 * 1024;
long Mb = Kb * 1024;
long Gb = Mb * 1024;
long Tb = Gb * 1024;
long Pb = Tb * 1024;
long Eb = Pb * 1024;
if (size < Kb) return floatForm( size ) + " byte";
if (size >= Kb && size < Mb) return floatForm((double)size/Kb) + " Kb";
if (size >= Mb && size < Gb) return floatForm((double)size/Mb) + " Mb";
if (size >= Gb && size < Tb) return floatForm((double)size/Gb) + " Gb";
if (size >= Tb && size < Pb) return floatForm((double)size/Tb) + " Tb";
if (size >= Pb && size < Eb) return floatForm((double)size/Pb) + " Pb";
if (size >= Eb) return floatForm((double)size/Eb) + " Eb";
return "???";
}
गणित करने से पहले आपको ब्लॉककाउंट और ब्लॉक आकार को लंबे समय तक डालना होगा। अन्यथा ये विधियां नकारात्मक मान वापस कर सकती हैं, क्योंकि कुल ब्लॉक गिनती समय ब्लॉक आकार int के लिए अधिकतम मान से अधिक हो जाएगा। हां, मैंने कोड का इस्तेमाल किया और नकारात्मक पाया। – christophercotton
@ क्रिस्टोफरकटन धन्यवाद! किया हुआ। – XXX
आपको वास्तव में (लंबे) statFs.getBlockCount() * (long) statFs.getBlockSize() को यह सुनिश्चित करने के लिए करना होगा कि वे सही तरीके से डालें। – christophercotton
/**
* @return Number of bytes available on internal storage
*/
public static long getInternalAvailableSpace() {
long availableSpace = -1L;
try {StatFs stat = new StatFs(Environment.getDataDirectory()
.getPath());
stat.restat(Environment.getDataDirectory().getPath());
availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
} catch (Exception e) {
e.printStackTrace();
}
return availableSpace;
}
इस लिंक देखें: Android get free size of internal/external memory इससे मदद मिल सकती है। यहां, सबकुछ एक अच्छे तरीके से समझाया गया है।
कुछ तरीकों जो 2013 के बाद से गूगल द्वारा पदावनत किया गया है और आप इन तरीकों (एपीआई 18+ केवल) बदल सकता है:
getAvailableBlocks()
को getAvailableBlocksLong()
getBlockCount()
getBlockCountLong()
getBlockSize()
को getBlockSizeLong()
getFreeBlocks()
से getFreeBlocksLong()
[एंड्रॉइड का आंतरिक डुप्लिकेट आंतरिक/बाहरी मेमोरी का मुफ्त आकार प्राप्त करें] (https://stackoverflow.com/questions/8133417/android-get-free-size-of-internal-external-memory) –