IPhone / iPad डिवाइस पर कुल उपलब्ध / मुफ्त डिस्क स्थान का पता कैसे लगाएं?

Question

मैं iPhone / iPad डिवाइस पर प्रोग्रामेटिक रूप से उपलब्ध / मुक्त डिस्क स्थान का पता लगाने के लिए एक बेहतर तरीके की तलाश कर रहा हूं।
वर्तमान में मैं डिस्क स्पेस का पता लगाने के लिए NSFileManager का उपयोग कर रहा हूं। निम्नलिखित कोड का स्निपेट है जो मेरे लिए काम करता है:

-(unsigned)getFreeDiskspacePrivate {
NSDictionary *atDict = [[NSFileManager defaultManager] attributesOfFileSystemForPath:@"/" error:NULL];
unsigned freeSpace = [[atDict objectForKey:NSFileSystemFreeSize] unsignedIntValue];
NSLog(@"%s - Free Diskspace: %u bytes - %u MiB", __PRETTY_FUNCTION__, freeSpace, (freeSpace/1024)/1024);

return freeSpace;
}

क्या मैं उपरोक्त स्निपेट के साथ सही हूं? या कुल उपलब्ध / मुक्त डिस्क स्थान को जानने का कोई बेहतर तरीका है।
मुझे कुल खाली डिस्क स्थान का पता लगाना है, क्योंकि हम अपने एप्लिकेशन को कम डिस्क स्थान परिदृश्य में सिंक करने के लिए रोकते हैं।

Comments

मुझे उम्मीद है कि

— स्टैकेओवरफ्लो

ऐसा लगता है कि वह अपने प्रश्न में जिस कोड का उपयोग कर रहा है, वह आपके द्वारा दिए गए लिंक के कोड से बेहतर है (वह "/" के तहत सभी उप-निर्देशिकाओं को

— ट्रेस

लिंक के लिए धन्यवाद मिखाइल। लेकिन मैं iPhone / iPad डिवाइस पर कुल उपलब्ध / मुफ्त डिस्क स्थान ढूंढ रहा हूं, न कि केवल एक विशेष फ़ोल्डर। उदाहरण के लिए, एक 32GB iPhone पर, यदि कुल उपलब्ध / मुफ्त आकार 28GB है, तो मुझे उस प्रोग्राम को पता लगाने में सक्षम होना चाहिए।

— कोड.वियार

मुझे आशा है कि यह लिंक मदद करता है: jayprakashdubey.blogspot.in/2014/07/…

— जयप्रकाश दुबे

Answer 1

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

मूल उत्तर : मेरे लिए निम्नलिखित समाधान काम कर रहे हैं:

-(uint64_t)getFreeDiskspace {
    uint64_t totalSpace = 0;
    uint64_t totalFreeSpace = 0;
    NSError *error = nil;  
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);  
    NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error: &error];  

    if (dictionary) {  
        NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];  
        NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
        totalSpace = [fileSystemSizeInBytes unsignedLongLongValue];
        totalFreeSpace = [freeFileSystemSizeInBytes unsignedLongLongValue];
        NSLog(@"Memory Capacity of %llu MiB with %llu MiB Free memory available.", ((totalSpace/1024ll)/1024ll), ((totalFreeSpace/1024ll)/1024ll));
    } else {  
        NSLog(@"Error Obtaining System Memory Info: Domain = %@, Code = %ld", [error domain], (long)[error code]);
    }  

    return totalFreeSpace;
}

यह मुझे बिल्कुल उसी आकार में लौटाता है जो आइट्यून्स प्रदर्शित करता है जब डिवाइस मशीन से जुड़ा होता है।

Comments

एक फ्लोट में बदलने से लगभग 2GB ऊपर गलत परिणाम दे सकता है। यदि आपको वास्तव में बड़े फ़ाइल आकारों से निपटने की आवश्यकता है, तो इसके बजाय एक डबल या लंबे डबल का उपयोग करें।

— ऐश

जैसा कि ऐश द्वारा बताया गया है, इस पद्धति का एक गलत परिणाम है। मेरे आईपैड 2 में, 64 जीबी के साथ, यह +0.25 जीबी तक विफल रहता है ... डेविड एच द्वारा पोस्ट किया गया नीचे का तरीका, uint64_t var का उपयोग करते समय सटीक परिणाम है।

— लिएंड्रो ने

कोड स्निपेट को नीचे दिखाए गए अनुसार @ दाविद एच के सुझावों को प्रतिबिंबित करने के लिए संपादित किया गया है।

— कोड.वारियर

+200 एमबी कोई समस्या नहीं है। सेटिंग्स में मेरे पास "0 बाइट्स" उपलब्ध स्थान है। और जब मैं अपने ऐप को दर्ज करता हूं और उपयोग करता हूं, तो यह विधि 150mb मुक्त स्थान के बारे में रिपोर्ट करती है। फिर मैं इस शेष स्थान को भरता हूं और उसके बाद ही ऐप क्रैश होता है। तो मैं कहूंगा कि यह तरीका आपको सेटिंग्स में जो दिखता है उससे ज्यादा सही जानकारी देता है।

— ancajic

NSUIntegerजैसे सामान की बजाय कोई उपयोग क्यों नहीं कर रहा है uint64_t? हम ओब्ज-सी लिख रहे हैं, न कि C ++ या C. NSUInteger अब आपको एक अहस्ताक्षरित 64 बिट पूर्णांक देगा, लेकिन अगर चीजें बदलने के लिए होती हैं तो मुझे लगता है कि Apple अपडेट करेगा कि मैक्रो (चलो किसी बिंदु पर 128 बिट्स कहते हैं, वास्तविक हो जाता है)

— गोलियां

Answer 2

अहस्ताक्षरित लंबे समय का उपयोग कर संशोधित स्रोत:

- (uint64_t)freeDiskspace
{
    uint64_t totalSpace = 0;
    uint64_t totalFreeSpace = 0;

    __autoreleasing NSError *error = nil;  
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);  
    NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error: &error];  

    if (dictionary) {  
        NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];  
        NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
        totalSpace = [fileSystemSizeInBytes unsignedLongLongValue];
        totalFreeSpace = [freeFileSystemSizeInBytes unsignedLongLongValue];
        NSLog(@"Memory Capacity of %llu MiB with %llu MiB Free memory available.", ((totalSpace/1024ll)/1024ll), ((totalFreeSpace/1024ll)/1024ll));
    } else {  
        NSLog(@"Error Obtaining System Memory Info: Domain = %@, Code = %d", [error domain], [error code]);  
    }  

    return totalFreeSpace;
}

संपादित करें: ऐसा लगता है कि किसी ने इस कोड को 'अहस्ताक्षरित लंबे समय' के बजाय 'uint64_t' का उपयोग करने के लिए संपादित किया है। निकट भविष्य में जबकि यह ठीक होना चाहिए, वे समान नहीं हैं। 'uint64_t' 64 बिट्स है और हमेशा यही रहेगा। 10 साल में 'अहस्ताक्षरित लंबा लंबा' 128 हो सकता है। यह एक छोटा बिंदु है लेकिन मैंने अहस्ताक्षरित का उपयोग क्यों किया।

Comments

मेरे पास नए स्वचालित गणना प्रणाली के साथ अनुभव नहीं है, लेकिन __autoreleasing के लिए क्या है? आपको आमतौर पर NSError को ऑटोरेलिज़ करने की ज़रूरत नहीं है

— Reverend

यह मदद कर सकता है: stackoverflow.com/questions/8862023/…

— फैबियन क्रेज़र

IOS 5.1 पर चलने वाले मेरे iPod टच 4th Gen पर, NSFileSystemFreeSize अभी भी ~ 200 MBytes बहुत अधिक रिपोर्टिंग कर रहा है। मैं डीबगर में पूरे NS ढंक की सामग्री का प्रिंट आउट करता हूं ... NSFileSystemSize सही है हालांकि ... किसी के पास इस समस्या का समाधान है?

— Zennichimaro

@Zennichimaro: क्या आपने अपनी समस्या ठीक की? मैं भी इसी मुद्दे का सामना कर रहा हूं, जब मैं iPad में मुफ्त स्थान की जांच कर रहा हूं तो 0.2 जीबी अतिरिक्त मिल रहा है। iPad 24.1 GB उपलब्ध स्थान दिखा रहा है, लेकिन कोड में यह 24.3 GB दिखा रहा है।

— सुधीर कुमार पालचुरी

@Diejmon आप NSNumber को इस प्रकार के पूर्णांक आकार के लिए नहीं कह सकते। यही कारण है कि ऐसी चीजों के लिए मुझे ज्ञात बिट आकार की एक इकाई पसंद है। जबकि तकनीकी रूप से मैं आपके कथन से सहमत हूं, मेरे पास पहले से ही NSInteger और प्रारूप स्ट्रिंग्स का उपयोग करने से निपटने के लिए पर्याप्त चेतावनी है! 64 बिट्स मेरे जीवनकाल और आपके लिए निश्चित रूप से पर्याप्त बिट्स होंगे।

— डेविड एच।

Answer 3

मैंने स्विफ्ट का उपयोग करके उपलब्ध / उपयोग की गई स्मृति प्राप्त करने के लिए एक वर्ग लिखा है। डेमो में: https://github.com/thanhcuong1990/swift-disk-status
स्विफ्ट 4 अपडेट किया गया।

import UIKit

class DiskStatus {

    //MARK: Formatter MB only
    class func MBFormatter(_ bytes: Int64) -> String {
        let formatter = ByteCountFormatter()
        formatter.allowedUnits = ByteCountFormatter.Units.useMB
        formatter.countStyle = ByteCountFormatter.CountStyle.decimal
        formatter.includesUnit = false
        return formatter.string(fromByteCount: bytes) as String
    }


    //MARK: Get String Value
    class var totalDiskSpace:String {
        get {
            return ByteCountFormatter.string(fromByteCount: totalDiskSpaceInBytes, countStyle: ByteCountFormatter.CountStyle.file)
        }
    }

    class var freeDiskSpace:String {
        get {
            return ByteCountFormatter.string(fromByteCount: freeDiskSpaceInBytes, countStyle: ByteCountFormatter.CountStyle.file)
        }
    }

    class var usedDiskSpace:String {
        get {
            return ByteCountFormatter.string(fromByteCount: usedDiskSpaceInBytes, countStyle: ByteCountFormatter.CountStyle.file)
        }
    }


    //MARK: Get raw value
    class var totalDiskSpaceInBytes:Int64 {
        get {
            do {
                let systemAttributes = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory() as String)
                let space = (systemAttributes[FileAttributeKey.systemSize] as? NSNumber)?.int64Value
                return space!
            } catch {
                return 0
            }
        }
    }

    class var freeDiskSpaceInBytes:Int64 {
        get {
            do {
                let systemAttributes = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory() as String)
                let freeSpace = (systemAttributes[FileAttributeKey.systemFreeSize] as? NSNumber)?.int64Value
                return freeSpace!
            } catch {
                return 0
            }
        }
    }

    class var usedDiskSpaceInBytes:Int64 {
        get {
            let usedSpace = totalDiskSpaceInBytes - freeDiskSpaceInBytes
            return usedSpace
        }
    }

}

डेमो

Comments

क्या आपके पास कोई विचार है कि MBFormatter क्यों है? इसका कहीं भी इस्तेमाल नहीं होता है।

— बेन सिनक्लेयर

MBFormatter किसी भी मान को MB मान में बदलने के लिए एक फ़ंक्शन है। मैं इसे डेमो प्रोजेक्ट के लिए उपयोग नहीं कर रहा हूँ। लेकिन मुझे दूसरे प्रोजेक्ट की जरूरत है।

— Cuong Lam

यह एक FileManager एक्सटेंशन में डालने के लिए बहुत अच्छा है।

— लियोन

आईट्यून्स 18.99 जीबी मुफ्त दिखाता है लेकिन जब मैं वर्णित विधियों का उपयोग करता हूं तो मुझे 13.41 जीबी मिलता है। क्या किसी को पता है कि मुझे क्या याद है?

— विटालि बोयार्स्की

@CuongLam अनवापिंग त्रुटियां फेंकी नहीं जाती हैं और उन्हें कैच / कैच से नहीं पकड़ा जाता है। त्रुटियों को सही ढंग से संभालने के लिए नमूना स्रोत कोड लिखा जाना चाहिए। stackoverflow.com/questions/34628999/…

— SafeFastExpressive

Answer 4

यदि आपको आकार के साथ स्वरूपित स्ट्रिंग की आवश्यकता है तो आप GitHub पर अच्छी लाइब्रेरी देख सकते हैं :

#define MB (1024*1024)
#define GB (MB*1024)

@implementation ALDisk

#pragma mark - Formatter

+ (NSString *)memoryFormatter:(long long)diskSpace {
    NSString *formatted;
    double bytes = 1.0 * diskSpace;
    double megabytes = bytes / MB;
    double gigabytes = bytes / GB;
    if (gigabytes >= 1.0)
        formatted = [NSString stringWithFormat:@"%.2f GB", gigabytes];
    else if (megabytes >= 1.0)
        formatted = [NSString stringWithFormat:@"%.2f MB", megabytes];
    else
        formatted = [NSString stringWithFormat:@"%.2f bytes", bytes];

    return formatted;
}

#pragma mark - Methods

+ (NSString *)totalDiskSpace {
    long long space = [[[[NSFileManager defaultManager] attributesOfFileSystemForPath:NSHomeDirectory() error:nil] objectForKey:NSFileSystemSize] longLongValue];
    return [self memoryFormatter:space];
}

+ (NSString *)freeDiskSpace {
    long long freeSpace = [[[[NSFileManager defaultManager] attributesOfFileSystemForPath:NSHomeDirectory() error:nil] objectForKey:NSFileSystemFreeSize] longLongValue];
    return [self memoryFormatter:freeSpace];
}

+ (NSString *)usedDiskSpace {
    return [self memoryFormatter:[self usedDiskSpaceInBytes]];
}

+ (CGFloat)totalDiskSpaceInBytes {
    long long space = [[[[NSFileManager defaultManager] attributesOfFileSystemForPath:NSHomeDirectory() error:nil] objectForKey:NSFileSystemSize] longLongValue];
    return space;
}

+ (CGFloat)freeDiskSpaceInBytes {
    long long freeSpace = [[[[NSFileManager defaultManager] attributesOfFileSystemForPath:NSHomeDirectory() error:nil] objectForKey:NSFileSystemFreeSize] longLongValue];
    return freeSpace;
}

+ (CGFloat)usedDiskSpaceInBytes {
    long long usedSpace = [self totalDiskSpaceInBytes] - [self freeDiskSpaceInBytes];
    return usedSpace;
}

Comments

प्रारूपित करने के लिए, कोई NSBytCounterFormatter

— डैनियल

यह अभी भी उसी + 200MB बग के लिए प्रवण है: stackoverflow.com/questions/9270027/…

— पॉलियस लेकिस

Answer 5

'अहस्ताक्षरित' का उपयोग न करें, यह केवल 32 बिट्स है जो पिछले 4GB से अधिक बह जाएगा, जो कि विशिष्ट iPad / iPhone मुक्त स्थान से कम है। अहस्ताक्षरित लंबे समय (या uint64_t) का उपयोग करें, और NSNumber से 64-बिट int के रूप में मान भी अहस्ताक्षरितLongValue का उपयोग कर प्राप्त करें।

Comments

एक टिप से बेहतर है - "इसका कानून" :-) जैसा कि उन्होंने कहा, मूल कोड सिर्फ सादा गलत है।

— डेविड एच

Answer 6

यदि आपकी तलाश स्विफ्ट का उपयोग करके शेष शेष स्थान को प्राप्त करने की है तो यह थोड़ा अलग है। आपको विशेषताएँ का उपयोग करने की आवश्यकता हैOfFileSystemForPath () के बजाय ItOfItemAtPath ():

func deviceRemainingFreeSpaceInBytes() -> Int64? {
    let documentDirectoryPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)
    var attributes: [String: AnyObject]
    do {
        attributes = try NSFileManager.defaultManager().attributesOfFileSystemForPath(documentDirectoryPath.last! as String)
        let freeSize = attributes[NSFileSystemFreeSize] as? NSNumber
        if (freeSize != nil) {
            return freeSize?.longLongValue
        } else {
            return nil
        }
    } catch {
        return nil
    }
}

संपादित करें: स्विफ्ट 1.0 के लिए अपडेट किया गया
संपादन 2: मार्टिन आर के जवाब का उपयोग करके सुरक्षा के लिए अपडेट किया गया ।
संपादित करें 3: स्विफ्ट 2.0 के लिए अपडेट किया गया ( डगलो द्वारा )

Comments

मैं इस उत्तर का उपयोग करने की कोशिश कर रहा था, लेकिन यह जीएम ([NSObject: AnyObject] के तहत संकलन नहीं करेगा। 'सबस्क्रिप्ट' नाम का सदस्य नहीं है)। मुझे लगता है कि यह मुद्दा यहां उठाया गया है, लेकिन मुझे समझ नहीं आ रहा है कि इस संदर्भ में उस उत्तर को कैसे काम किया जाए। किसी भी मदद की बहुत सराहना की।

— ब्रायन हैंसन

मैंने स्विफ्ट 1.0 पर काम करने के उत्तर को अभी अपडेट किया है। क्योंकि FeaturesOfFileSystemForPath रिटर्न [NSObject: AnyObject]? आपको NS सहकर्मी को कास्ट करने की आवश्यकता है? के रूप में यह शून्य हो सकता है और फिर इसे सदस्यता के लिए शब्दकोश को खोलना नहीं है। (यह थोड़ा सा असुरक्षित है, इसलिए मैं उत्तर को थोड़ा सुरक्षित समाधान के साथ बाद में अपडेट करूंगा जब मेरे पास समय होगा।)

— रुबेनसंदैंड

अद्यतन के लिए धन्यवाद। यह पता चला है के रूप में अपने जवाब से पहले एक घंटे के बारे में, मैं चला गया है आगे था और एक नए सिरे से सवाल के रूप में इस मुद्दे को तैयार यहाँ । अब वहाँ एक उत्तर है, लेकिन चूंकि वैकल्पिक तरीकों से निपटने का यह तरीका मेरे लिए थोड़ा अपारदर्शी है, मुझे आपकी सुविधा में एक और दृष्टिकोण देखना अच्छा लगेगा। अपनी बहन रेचल को मेरा सम्मान देना।

— ब्रायन हैनसन

ब्रायन, मैं आपके उत्तर वाले प्रश्न का पहला उत्तर देना चाहूंगा क्योंकि यह सुरक्षा और स्पष्टता का एक अच्छा मिश्रण है। मुझे यकीन नहीं है कि मैं फिर एक बेहतर जवाब दे सकता हूं। वैकल्पिक पहले से भ्रमित हो सकते हैं, मैं दृढ़ता से स्विफ्ट मैनुअल अनुभाग को वैकल्पिक पर पढ़ने का सुझाव देता हूं यह काफी अच्छा है।

— RubenSandwich

बहुत सराहना की, मैं उस मैनुअल को फिर से देखूंगा और मुझे कुछ अच्छे एसओ प्रश्न भी मिल गए हैं। ब्रायन

— ब्रायन हैनसन

Answer 7

यहाँ मेरा जवाब है और यह बेहतर क्यों है।

उत्तर (स्विफ्ट):

func remainingDiskSpaceOnThisDevice() -> String {
    var remainingSpace = NSLocalizedString("Unknown", comment: "The remaining free disk space on this device is unknown.")
    if let attributes = try? FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory()),
        let freeSpaceSize = attributes[FileAttributeKey.systemFreeSize] as? Int64 {
        remainingSpace = ByteCountFormatter.string(fromByteCount: freeSpaceSize, countStyle: .file)
    }
    return remainingSpace
}

उत्तर (उद्देश्य-सी):

- (NSString *)calculateRemainingDiskSpaceOnThisDevice
{
    NSString *remainingSpace = NSLocalizedString(@"Unknown", @"The remaining free disk space on this device is unknown.");
    NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:NSHomeDirectory() error:nil];
    if (dictionary) {
        long long freeSpaceSize = [[dictionary objectForKey:NSFileSystemFreeSize] longLongValue];
        remainingSpace = [NSByteCountFormatter stringFromByteCount:freeSpaceSize countStyle:NSByteCountFormatterCountStyleFile];
    }
    return remainingSpace;
}

यह बेहतर क्यों है:

• लाइब्रेरी में निर्मित कोको का उपयोग करता है NSByteCountFormatter, जिसका अर्थ है बाइट्स से गीगाबाइट्स तक कोई पागल मैनुअल गणना नहीं। Apple आपके लिए ऐसा करता है!
• आसानी से अनुवाद करने योग्य: NSByteCountFormatter यह आपके लिए करता है। उदाहरण के लिए, जब डिवाइस की भाषा अंग्रेजी में सेट होती है, तो स्ट्रिंग 248.8 एमबी पढ़ेगी, लेकिन अन्य भाषाओं के लिए फ्रेंच, एट सेटेरा के लिए सेट होने पर 248,8 मो पढ़ेगी।
• त्रुटि के मामले में एक डिफ़ॉल्ट मान दिया जाता है।

Comments

@JuanBoero 3.1 में प्रकाशित किया गया था 3.1 (अंत में)!

— क्रिसजेएफ

Answer 8

महत्वपूर्ण स्पष्टीकरण (कम से कम मेरे लिए)। अगर मैं अपने आइपॉड को अपने मैक से जोड़ता हूं तो यह आईट्यून्स ऐप द्वारा दिखाई गई जानकारी है।

जब मैं उपरोक्त कोड का उपयोग करता हूं:

long long freeSpace = [[[[NSFileManager defaultManager] attributesOfFileSystemForPath:NSHomeDirectory() error:nil]
                            objectForKey:NSFileSystemFreeSize] longLongValue];

NSString *free1 = [NSByteCountFormatter stringFromByteCount:freeSpace countStyle:NSByteCountFormatterCountStyleFile];

[label1 setText:free1];

NSString *free2 = [NSByteCountFormatter stringFromByteCount:freeSpace countStyle:NSByteCountFormatterCountStyleBinary];

[label2 setText:free2];

द काउंटसाइल NSByteCountFormatterCountStyleFile मुझे दिखाओ: 17,41 जीबी

द काउंटसाइल NSByteCountFormatterCountStyleBinary मुझे दिखाओ: 16,22 GB

16,22 GB ( NSByteCountFormatterCountStyleBinary ) यह वास्तव में वह संख्या है जो आईपॉड ऐप मुझे तब दिखाती है जब मैं अपने मैक से अपना आईपॉड कनेक्ट करता हूं।

Comments

शायद फ़ाइल केवल मैक फ़ाइलों के लिए है और iOS के लिए नहीं है?

— जोओ न्यून्स

यह बाइट की समान मात्रा 1000 (KB फिर MB तब GB) बनाम 1024 है।

— जिम75

Answer 9

IOS11 में उपलब्ध डिस्क पर उपलब्ध आकार पाने के लिए एक नए सटीक एपीआई के साथ अपडेट करें। यहाँ नई एपीआई संसाधन कुंजी के लिए विवरण दिया गया है:

#if os(OSX) || os(iOS)
/// Total available capacity in bytes for "Important" resources, including space expected to be cleared by purging non-essential and cached resources. "Important" means something that the user or application clearly expects to be present on the local system, but is ultimately replaceable. This would include items that the user has explicitly requested via the UI, and resources that an application requires in order to provide functionality.
/// Examples: A video that the user has explicitly requested to watch but has not yet finished watching or an audio file that the user has requested to download.
/// This value should not be used in determining if there is room for an irreplaceable resource. In the case of irreplaceable resources, always attempt to save the resource regardless of available capacity and handle failure as gracefully as possible.
@available(OSX 10.13, iOS 11.0, *) @available(tvOS, unavailable) @available(watchOS, unavailable)
public var volumeAvailableCapacityFor Usage: Int64? { return _get(.volumeAvailableCapacityForImportantUsageKey) }
#endif

मैं कुंजी " FileAttributeKey.systemFreeSize " और कुंजी " URLResourceKey.volumeAvailableCapacityForImportantUsageKey " से परिणामों की तुलना करता हूं और पाया गया कि परिणाम " वॉल्यूमअवलेप कैचेसीForImportantUsageKey " के रूप में उपलब्ध स्टोरेज से बिल्कुल मेल खाते हैं। यहाँ तेजी से कार्यान्वयन है:

class var freeDiskSpaceInBytesImportant:Int64 {
    get {
        do {
            return try URL(fileURLWithPath: NSHomeDirectory() as String).resourceValues(forKeys: [URLResourceKey.volumeAvailableCapacityForImportantUsageKey]).volumeAvailableCapacityForImportantUsage!
        } catch {
            return 0
        }
    }
}

Comments

आपके स्क्रीनशॉट पर "अवसरवादी उपयोग" कहां से आ रहा है?

— rshev

यह पाया volumeAvailableCapacityForOpportunisticUsageKey।

— rshev

हाँ rshev, volumeAvailableCapacityForOkutunisticUsageKey को मेरे स्क्रीनशॉट पर "अवसरवादी उपयोग"

— मिलता है

उपलब्ध भंडारण आकार के साथ मैं क्वेरी चाहिए देखने के लिए NSHomeDirectory()या NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.documentDirectory, FileManager.SearchPathDomainMask.userDomainMask, true)। क्या इन दोनों के उपयोग से कोई अंतर है?

— सूर्यकांत शर्मा 5

Answer 10

आप स्विफ्ट 4 का उपयोग करके एक और समाधान पा सकते हैं और extensionजो आपको एक अच्छा विकल्प देता है।

यहाँ UIDeviceविस्तार है।

extension UIDevice {

    func totalDiskSpaceInBytes() -> Int64 {
        do {
            guard let totalDiskSpaceInBytes = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory())[FileAttributeKey.systemSize] as? Int64 else {
                return 0
            }
            return totalDiskSpaceInBytes
        } catch {
            return 0
        }
    }

    func freeDiskSpaceInBytes() -> Int64 {
        do {
            guard let totalDiskSpaceInBytes = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory())[FileAttributeKey.systemFreeSize] as? Int64 else {
                return 0 
            }
            return totalDiskSpaceInBytes
        } catch {
            return 0
        }
    }

    func usedDiskSpaceInBytes() -> Int64 {
        return totalDiskSpaceInBytes() - freeDiskSpaceInBytes()
    }

    func totalDiskSpace() -> String {
        let diskSpaceInBytes = totalDiskSpaceInBytes()
        if diskSpaceInBytes > 0 {
            return ByteCountFormatter.string(fromByteCount: diskSpaceInBytes, countStyle: ByteCountFormatter.CountStyle.binary)
        }
        return "The total disk space on this device is unknown"
    }

    func freeDiskSpace() -> String {
        let freeSpaceInBytes = freeDiskSpaceInBytes()
        if freeSpaceInBytes > 0 {
            return ByteCountFormatter.string(fromByteCount: freeSpaceInBytes, countStyle: ByteCountFormatter.CountStyle.binary)
        }
        return "The free disk space on this device is unknown"
    }

    func usedDiskSpace() -> String {
        let usedSpaceInBytes = totalDiskSpaceInBytes() - freeDiskSpaceInBytes()
        if usedSpaceInBytes > 0 {
            return ByteCountFormatter.string(fromByteCount: usedSpaceInBytes, countStyle: ByteCountFormatter.CountStyle.binary)
        }
        return "The used disk space on this device is unknown"
    }

}

और नमूना उपयोग:

UIDevice.current.totalDiskSpaceInBytes()
UIDevice.current.totalDiskSpace()
UIDevice.current.freeDiskSpaceInBytes()
UIDevice.current.freeDiskSpace()
UIDevice.current.usedDiskSpaceInBytes()
UIDevice.current.usedDiskSpace()

Comments

!इसके बजाय guardसुरक्षित typecastingया nilजाँच करने के लिए उपयोग न करें।

— द टाइगर

आपकी टिप्पणियों के लिए धन्यवाद @ TheTiger।

— अब्दुल्लाहसेलेक

Answer 11

IOS> = 6.0 के लिए आप नए का उपयोग कर सकते हैं NSByteCountFormatter। इस कोड को एक स्वरूपित स्ट्रिंग के रूप में शेष बाइट्स की संख्या मिलती है।

NSError *error = nil;
NSArray * const paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSDictionary * const pathAttributes = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths firstObject] error:&error];
NSAssert(pathAttributes, @"");
NSNumber * const fileSystemSizeInBytes = [pathAttributes objectForKey: NSFileSystemFreeSize];
const long long numberOfBytesRemaining = [fileSystemSizeInBytes longLongValue];
NSByteCountFormatter *byteCountFormatter = [[NSByteCountFormatter alloc] init];
NSString *formattedNmberOfBytesRemaining = [byteCountFormatter stringFromByteCount:numberOfBytesRemaining];

Answer 12

निम्नलिखित कोड है स्विफ्ट 3.0 संस्करण क्रिसजेएफ द्वारा पहले दिए गए उत्तर का कार्यान्वयन:

func freeSpaceInBytes() -> NSString {

    var remainingSpace = NSLocalizedString("Unknown", comment: "The remaining free disk space on this device is unknown.")

    do {
        let dictionary =  try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory())
        let freeSpaceSize = ((dictionary[FileAttributeKey.systemFreeSize] as AnyObject).longLongValue)!
        remainingSpace = ByteCountFormatter.string(fromByteCount: freeSpaceSize, countStyle: ByteCountFormatter.CountStyle.file)
    }
    catch let error {
        NSLog(error.localizedDescription)
    }

    return remainingSpace as NSString

}

Comments

ऐसा क्यों है कि iPhone तो उपलब्ध डिस्क स्थान की जानकारी और अधिक लौट रहा है। जब iPhones का सेटअप मेनू 998MB कहता है, तो वह 1.2 जीबी

— होप

Answer 13

UIDevice एक्सटेंशन के रूप में स्विफ्ट के लिए

extension UIDevice {
    func freeDiskspace() -> NSString {
        let failedResult: String = "Error Obtaining System Memory"
        guard let path = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true).last else {
            return failedResult
        }
        do {
            let dictionary = try NSFileManager.defaultManager().attributesOfFileSystemForPath(path)
            if let fileSystemSizeInBytes = dictionary[NSFileSystemSize] as? UInt,
                let freeFileSystemSizeInBytes =     dictionary[NSFileSystemFreeSize] as? UInt {
                    return "Memory \(freeFileSystemSizeInBytes/1024/1024) of \(fileSystemSizeInBytes/1024/1024) Mb available."
            } else {
                    return failedResult
            }
        } catch {
            return failedResult
        }
    }
}

कैसे इस्तेमाल करे:

print("\(UIDevice.currentDevice().freeDiskspace())")

आउटपुट होगा:

Memory 9656 of 207694 Mb available.

Answer 14

मुझे पता है कि यह पोस्ट थोड़ी पुरानी है, लेकिन मुझे लगता है कि यह उत्तर किसी की मदद कर सकता है। यदि आप डिवाइस पर उपयोग / मुक्त / कुल डिस्क स्थान जानना चाहते हैं तो आप Luminous का उपयोग कर सकते हैं । यह स्विफ्ट में लिखा है। आपको केवल कॉल करना है:

Luminous.System.Disk.freeSpace()
Luminous.System.Disk.usedSpace()

या

Luminous.System.Disk.freeSpaceInBytes()
Luminous.System.Disk.usedSpaceInBytes()

Answer 15

उपरोक्त कोड का स्विफ्ट कार्यान्वयन: -

import UIKit

class DiskInformation: NSObject {

    var totalSpaceInBytes: CLongLong = 0; // total disk space
    var totalFreeSpaceInBytes: CLongLong = 0; //total free space in bytes

    func getTotalDiskSpace() -> String { //get total disk space
        do{
        let space: CLongLong = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory())[FileAttributeKey.systemSize] as! CLongLong; //Check for home dirctory and get total system size
            totalSpaceInBytes = space; // set as total space
            return memoryFormatter(space: space); // send the total bytes to formatter method and return the output

        }catch let error{ // Catch error that may be thrown by FileManager
            print("Error is ", error);
        }
        return "Error while getting memory size";
    }

    func getTotalFreeSpace() -> String{ //Get total free space
        do{
            let space: CLongLong = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory())[FileAttributeKey.systemFreeSize] as! CLongLong;
            totalFreeSpaceInBytes = space;
            return memoryFormatter(space: space);

        }catch let error{
            print("Error is ", error);
        }
        return "Error while getting memory size";
    }

    func getTotalUsedSpace() -> String{ //Get total disk usage from above variable
        return memoryFormatter(space: (totalSpaceInBytes - totalFreeSpaceInBytes));
    }

    func memoryFormatter(space : CLongLong) -> String{ //Format the usage to return value with 2 digits after decimal
        var formattedString: String;

        let totalBytes: Double = 1.0 * Double(space);
        let totalMb: Double = totalBytes / (1024 * 1024);
        let totalGb: Double = totalMb / 1024;
        if (totalGb > 1.0){
            formattedString = String(format: "%.2f", totalGb);
        }else if(totalMb >= 1.0){
            formattedString = String(format: "%.2f", totalMb);
        }else{
            formattedString = String(format: "%.2f", totalBytes);
        }
        return formattedString;
    }


}

इसे किसी अन्य वर्ग से बुलाओ।

func getDiskInfo(){
        let diskInfo = DiskInformation();
        print("Total disk space is", diskInfo.getTotalDiskSpace(),"Gb");
        print("Total free space is", diskInfo.getTotalFreeSpace(),"Gb");
        print("Total used space is", diskInfo.getTotalUsedSpace(),"Gb");
    }

लौटाए गए मूल्य का परीक्षण करते समय, यह अन्य ऐप द्वारा दिखाया गया है। कम से कम मेरे आईफोन 6 एस + में। यह ऊपर दिखाए गए उत्तर का सिर्फ तेज कार्यान्वयन है। और मेरे लिए स्वीकृत जवाब से काम नहीं चला।

Answer 16

स्विफ्ट 2.1 संस्करण में क्रिसजेएफ का जवाब :

func freeSpaceInBytes() -> NSString{

    var remainingSpace = NSLocalizedString("Unknown", comment: "The remaining free disk space on this device is unknown.")

    do {

        let dictionary =  try NSFileManager.defaultManager().attributesOfFileSystemForPath(NSHomeDirectory())
        freeSpaceSize = (dictionary[NSFileSystemFreeSize]?.longLongValue)!
        remainingSpace = NSByteCountFormatter.stringFromByteCount(freeSpaceSize, countStyle: NSByteCountFormatterCountStyle.File)

    }
    catch let error as NSError {

        error.description
        NSLog(error.description)

    }

    return remainingSpace

}

Answer 17

यदि आप समय बचाना चाहते हैं, तो निम्न कोकोआइड लाइब्रेरी का उपयोग करें। मैंने इसका इस्तेमाल नहीं किया लेकिन ऐसा लगता है कि इसे काम करना चाहिए।

https://cocoapods.org/pods/SystemServices

Answer 18

FileManagerउचित त्रुटि से निपटने के लिए स्विफ्ट 5 एक्सटेंशन और कोई स्वचालित स्ट्रिंग रूपांतरण नहीं (बाइट काउंट को स्ट्रिंग में बदलें जैसा कि आप चाहें)। इसके अलावा FileManagerनामकरण है।

extension FileManager {
    func systemFreeSizeBytes() -> Result<Int64, Error> {
        do {
            let attrs = try attributesOfFileSystem(forPath: NSHomeDirectory())
            guard let freeSize = attrs[.systemFreeSize] as? Int64 else {
                return .failure(NSError(domain: "", code: 0, userInfo: [NSLocalizedDescriptionKey : "Can't retrieve system free size"]))
            }
            return .success(freeSize)
        } catch {
            return .failure(error)
        }
    }

    func systemSizeBytes() -> Result<Int64, Error> {
         do {
             let attrs = try attributesOfFileSystem(forPath: NSHomeDirectory())
             guard let size = attrs[.systemSize] as? Int64 else {
                 return .failure(NSError(domain: "", code: 0, userInfo: [NSLocalizedDescriptionKey : "Can't retrieve system size"]))
             }
             return .success(size)
         } catch {
             return .failure(error)
         }
     }
}

उदाहरण उपयोग:

let freeSizeResult = FileManager.default.systemFreeSizeBytes()
switch freeSizeResult {
case .failure(let error):
    print(error)
case .success(let freeSize):
    let freeSizeString = ByteCountFormatter.string(fromByteCount: freeSize, countStyle: .file)
    print("free size: \(freeSizeString)")
}