Android otrzymuje darmowy rozmiar pamięci wewnętrznej / zewnętrznej

98

Chcę programowo uzyskać rozmiar wolnej pamięci w pamięci wewnętrznej / zewnętrznej mojego urządzenia. Używam tego fragmentu kodu:

StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
long bytesAvailable = (long)stat.getBlockSize() *(long)stat.getBlockCount();
long megAvailable = bytesAvailable / 1048576;
Log.e("","Available MB : "+megAvailable);

File path = Environment.getDataDirectory();
StatFs stat2 = new StatFs(path.getPath());
long blockSize = stat2.getBlockSize();
long availableBlocks = stat2.getAvailableBlocks();
String format =  Formatter.formatFileSize(this, availableBlocks * blockSize);
Log.e("","Format : "+format);

a wynik jaki otrzymuję to:

11-15 10:27:18.844: E/(25822): Available MB : 7572
11-15 10:27:18.844: E/(25822): Format : 869MB

Problem polega na tym, że chcę uzyskać wolną pamięć SdCard, która jest 1,96GBteraz. Jak mogę naprawić ten kod, aby uzyskać darmowy rozmiar?

Android-Droid
źródło
Od poziomu API 18 zmienili nazwę metody na Long. Prawdopodobnie przedtem musiałbyś dodać sprawdzenie poziomu API
Jayshil Dave,
Wszystkie rozwiązania Próbowałem nie działać z nikim, kiedy formatuję jako pamięć wewnętrzną ... czy możesz mi się podobać, jak to zrobić?
Yogesh Rathi

Odpowiedzi:

182

Poniżej znajduje się kod do Twojego celu:

public static boolean externalMemoryAvailable() {
        return android.os.Environment.getExternalStorageState().equals(
                android.os.Environment.MEDIA_MOUNTED);
    }

    public static String getAvailableInternalMemorySize() {
        File path = Environment.getDataDirectory();
        StatFs stat = new StatFs(path.getPath());
        long blockSize = stat.getBlockSizeLong();
        long availableBlocks = stat.getAvailableBlocksLong();
        return formatSize(availableBlocks * blockSize);
    }

    public static String getTotalInternalMemorySize() {
        File path = Environment.getDataDirectory();
        StatFs stat = new StatFs(path.getPath());
        long blockSize = stat.getBlockSizeLong();
        long totalBlocks = stat.getBlockCountLong();
        return formatSize(totalBlocks * blockSize);
    }

    public static String getAvailableExternalMemorySize() {
        if (externalMemoryAvailable()) {
            File path = Environment.getExternalStorageDirectory();
            StatFs stat = new StatFs(path.getPath());
            long blockSize = stat.getBlockSizeLong();
            long availableBlocks = stat.getAvailableBlocksLong();
            return formatSize(availableBlocks * blockSize);
        } else {
            return ERROR;
        }
    }

    public static String getTotalExternalMemorySize() {
        if (externalMemoryAvailable()) {
            File path = Environment.getExternalStorageDirectory();
            StatFs stat = new StatFs(path.getPath());
            long blockSize = stat.getBlockSizeLong();
            long totalBlocks = stat.getBlockCountLong();
            return formatSize(totalBlocks * blockSize);
        } else {
            return ERROR;
        }
    }

    public static String formatSize(long size) {
        String suffix = null;

        if (size >= 1024) {
            suffix = "KB";
            size /= 1024;
            if (size >= 1024) {
                suffix = "MB";
                size /= 1024;
            }
        }

        StringBuilder resultBuffer = new StringBuilder(Long.toString(size));

        int commaOffset = resultBuffer.length() - 3;
        while (commaOffset > 0) {
            resultBuffer.insert(commaOffset, ',');
            commaOffset -= 3;
        }

        if (suffix != null) resultBuffer.append(suffix);
        return resultBuffer.toString();
    }

Uzyskaj rozmiar pamięci RAM

ActivityManager actManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
MemoryInfo memInfo = new ActivityManager.MemoryInfo();
actManager.getMemoryInfo(memInfo);
long totalMemory = memInfo.totalMem;
Dinesh Prajapati
źródło
2
getBlockSize()i getBlockCountsą przestarzałe.
Nima G
2
@DineshPrajapati Dzięki za odpowiedź, mam zapytanie, jeśli używam Environment.getRootDirectory () zamiast Environment.getDataDirectory do obliczania pamięci wewnętrznej, otrzymuję dane wyjściowe ... odnosi się to do pamięci wewnętrznej innej pamięci ...
AK Joshi
3
@DineshPrajapati .. Testowane na MOTO G2 Getting złego danych dla External Storage
AK Joshi
1
Użyj Long na końcu dla nowszych poziomów API (> 18)
Gun2sh
1
Dziękuję bardzo za podzielenie się wiedzą
Kishan Soni
40

Tak to zrobiłem:

StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
long bytesAvailable;
if (android.os.Build.VERSION.SDK_INT >= 
    android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
    bytesAvailable = stat.getBlockSizeLong() * stat.getAvailableBlocksLong();
}
else {
    bytesAvailable = (long)stat.getBlockSize() * (long)stat.getAvailableBlocks();
}
long megAvailable = bytesAvailable / (1024 * 1024);
Log.e("","Available MB : "+megAvailable);
Android-Droid
źródło
2
ale to jest pozbawione :(
abbasalim
@ ArMo372, Czy znaleźliście kod zastępczy do tego?
SimpleCoder,
3
Wystarczy zastąpić getBlockSizei getAvailableBlocksz getBlockSizeLonga getAvailableBlocksLong.
smg
1
to nie jest uzyskanie odpowiedniej dostępnej przestrzeni. To dostaje 1141 zamiast 1678 @smg
1
Rozwiązanie nie działa, gdy formatuję jako pamięć wewnętrzną ... czy możesz mnie zadowolić, jak to zrobić
Yogesh Rathi
27

Od API 9 możesz:

long freeBytesInternal = new File(ctx.getFilesDir().getAbsoluteFile().toString()).getFreeSpace();
long freeBytesExternal = new File(getExternalFilesDir(null).toString()).getFreeSpace();
Tzoiker
źródło
2
File.getUsableSpace () jest prawdopodobnie lepsza, ponieważ prawdopodobnie nie jesteś uruchomiony jako root.
Mark
Do File.getUsableSpace()wygląda łatwiejszy sposób używać zamiast używać StatFs. Dlaczego miałbym używać StatFs@MarkCarter?
StuStirling,
1
@ DiscoS2 Użyjesz StatFs, jeśli twoja minSdkVersion jest mniejsza niż 9.
Zaznacz
1
W jaki sposób monitorowałbyś również zmiany w pamięci masowej?
programista Androida
24

Aby uzyskać wszystkie dostępne foldery pamięci (w tym karty SD), najpierw pobierz pliki pamięci:

File internalStorageFile=getFilesDir();
File[] externalStorageFiles=ContextCompat.getExternalFilesDirs(this,null);

Następnie możesz uzyskać dostępny rozmiar każdego z nich.

Można to zrobić na 3 sposoby:

API 8 i starsze:

StatFs stat=new StatFs(file.getPath());
long availableSizeInBytes=stat.getBlockSize()*stat.getAvailableBlocks();

API 9 i nowsze:

long availableSizeInBytes=file.getFreeSpace();

API 18 i nowsze (niepotrzebne, jeśli poprzedni jest w porządku):

long availableSizeInBytes=new StatFs(file.getPath()).getAvailableBytes(); 

Aby uzyskać ładnie sformatowany ciąg tego, co masz teraz, możesz użyć:

String formattedResult=android.text.format.Formatter.formatShortFileSize(this,availableSizeInBytes);

lub możesz użyć tego w przypadku, gdy chcesz zobaczyć dokładną liczbę bajtów, ale ładnie:

NumberFormat.getInstance().format(availableSizeInBytes);

Zwróć uwagę, że myślę, że pamięć wewnętrzna może być taka sama jak pierwsza pamięć zewnętrzna, ponieważ pierwsza jest emulowana.


EDYCJA: Używając StorageVolume na Androidzie Q i nowszych, myślę, że można uzyskać wolne miejsce dla każdego, używając czegoś takiego:

    val storageManager = getSystemService(Context.STORAGE_SERVICE) as StorageManager
    val storageVolumes = storageManager.storageVolumes
    AsyncTask.execute {
        for (storageVolume in storageVolumes) {
            val uuid: UUID = storageVolume.uuid?.let { UUID.fromString(it) } ?: StorageManager.UUID_DEFAULT
            val allocatableBytes = storageManager.getAllocatableBytes(uuid)
            Log.d("AppLog", "allocatableBytes:${android.text.format.Formatter.formatShortFileSize(this,allocatableBytes)}")
        }
    }

Nie jestem pewien, czy to prawda i nie mogę znaleźć sposobu, aby uzyskać całkowity rozmiar każdego z nich, więc napisałem o tym tutaj i zapytałem o to tutaj .

programista Androida
źródło
1
Jak uzyskać wolne miejsce na wymiennej karcie SD (lub pendrive USB OTG) na urządzeniach z API 23? new StatFs (file.getPath ()). getAvailableBytes () lub file.getUsableSpace () daje 972546048 bajtów niezależnie od rzeczywistego rozmiaru pamięci na Nexusie 5 (Marshmallow 6.0.1).
nieobecny
@isabsent Nexus 5 nie ma gniazda na kartę SD. Jak to sprawdziłeś?
programista Androida
Sprawdziłem to z pendrive'em USB OTG.
nieobecny
@isabsent Nigdy go nie używałem. Przepraszam. Czy działa dobrze na API 22 i niższych?
programista Androida
1
@Smeet Czy można go wypróbować na Androidzie 6 lub nowszym? Jeśli tak, może jest to problem podobny do tego: code.google.com/p/android/issues/detail?id=200326
programista Androida
9

@ Android-Droid - mylisz się co Environment.getExternalStorageDirectory()do pamięci zewnętrznej, która nie musi być kartą SD, może być też zamontowana pamięć wewnętrzna. Widzieć:

Znajdź lokalizację zewnętrznej karty SD

Ostry80
źródło
7

Wypróbuj ten prosty fragment

    public static String readableFileSize() {
    long availableSpace = -1L;
    StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2)
        availableSpace = (long) stat.getBlockSizeLong() * (long) stat.getAvailableBlocksLong();
    else
        availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();

    if(availableSpace <= 0) return "0";
    final String[] units = new String[] { "B", "kB", "MB", "GB", "TB" };
    int digitGroups = (int) (Math.log10(availableSpace)/Math.log10(1024));
    return new DecimalFormat("#,##0.#").format(availableSpace/Math.pow(1024, digitGroups)) + " " + units[digitGroups];
}
Ness Tyagi
źródło
Dzięki ale mam java.lang.ArrayIndexOutOfBoundsException: length=5; index=-2147483648błąd wydaje się że digitGroupswynik to -2147483648.
Acuna
Rozwiązanie nie działa, gdy formatuję jako pamięć wewnętrzną ... czy możesz mnie zadowolić, jak to zrobić
Yogesh Rathi
6

Znalezienie dostępnej pamięci masowej jest bardzo łatwe, jeśli masz zarówno wewnętrzną, jak i zewnętrzną ścieżkę pamięci. Również zewnętrzna ścieżka pamięci telefonu jest naprawdę łatwa do znalezienia

Environment.getExternalStorageDirectory (). GetPath ();

Koncentruję się więc tylko na tym, jak znaleźć ścieżki zewnętrznej pamięci wymiennej, takiej jak wymienna karta SD, USB OTG (nie testowane USB OTG, ponieważ nie mam USB OTG).

Poniższa metoda poda listę wszystkich możliwych zewnętrznych ścieżek pamięci wymiennej.

 /**
     * This method returns the list of removable storage and sdcard paths.
     * I have no USB OTG so can not test it. Is anybody can test it, please let me know
     * if working or not. Assume 0th index will be removable sdcard path if size is
     * greater than 0.
     * @return the list of removable storage paths.
     */
    public static HashSet<String> getExternalPaths()
    {
    final HashSet<String> out = new HashSet<String>();
    String reg = "(?i).*vold.*(vfat|ntfs|exfat|fat32|ext3|ext4).*rw.*";
    String s = "";
    try
    {
        final Process process = new ProcessBuilder().command("mount").redirectErrorStream(true).start();
        process.waitFor();
        final InputStream is = process.getInputStream();
        final byte[] buffer = new byte[1024];
        while (is.read(buffer) != -1)
        {
            s = s + new String(buffer);
        }
        is.close();
    }
    catch (final Exception e)
    {
        e.printStackTrace();
    }

    // parse output
    final String[] lines = s.split("\n");
    for (String line : lines)
    {
        if (!line.toLowerCase(Locale.US).contains("asec"))
        {
            if (line.matches(reg))
            {
                String[] parts = line.split(" ");
                for (String part : parts)
                {
                    if (part.startsWith("/"))
                    {
                        if (!part.toLowerCase(Locale.US).contains("vold"))
                        {
                            out.add(part.replace("/media_rw","").replace("mnt", "storage"));
                        }
                    }
                }
            }
        }
    }
    //Phone's external storage path (Not removal SDCard path)
    String phoneExternalPath = Environment.getExternalStorageDirectory().getPath();

    //Remove it if already exist to filter all the paths of external removable storage devices
    //like removable sdcard, USB OTG etc..
    //When I tested it in ICE Tab(4.4.2), Swipe Tab(4.0.1) with removable sdcard, this method includes
    //phone's external storage path, but when i test it in Moto X Play (6.0) with removable sdcard,
    //this method does not include phone's external storage path. So I am going to remvoe the phone's
    //external storage path to make behavior consistent in all the phone. Ans we already know and it easy
    // to find out the phone's external storage path.
    out.remove(phoneExternalPath);

    return out;
}
Smeet
źródło
Jak pamiętam, używanie stałych nazw do obsługi ścieżek może nie działać na niektórych urządzeniach, ponieważ niektóre mogą mieć własne ścieżki. Mam nadzieję, że tak nie jest. +1 za wysiłek.
programista Androida
1
@androiddeveloper Dziękuję za uprzejme głosowanie. Potrzebuję wsparcia wszystkich, aby przetestować ten kod w twoim urządzeniu, ponieważ nie mam wszystkich urządzeń, ale przetestowałem je na 4 różnych urządzeniach i działają dobrze. Proszę o komentarz tutaj nie działa w telefonie komórkowym żadnego ciała.
Smeet
Rozwiązanie nie działa, gdy formatuję jako pamięć wewnętrzną ... czy możesz mnie zadowolić, jak to zrobić
Yogesh Rathi
4

Szybki dodatek do tematu Pamięć zewnętrzna

Nie daj się zmylić nazwą metody externalMemoryAvailable()w odpowiedzi Dinesha Prajapatiego.

Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())podaje aktualny stan pamięci, jeśli nośnik jest obecny i zamontowany w punkcie montowania z dostępem do odczytu / zapisu. Dostaniesz truenawet na urządzeniach bez kart SD, takich jak Nexus 5. Ale nadal jest to metoda obowiązkowa przed jakąkolwiek operacją z pamięcią masową.

Aby sprawdzić, czy w urządzeniu jest karta SD, możesz użyć metody ContextCompat.getExternalFilesDirs()

Nie pokazuje urządzeń przejściowych, takich jak dyski flash USB.

Należy również pamiętać, że ContextCompat.getExternalFilesDirs()na Androidzie 4.3 i niższych zawsze zwróci tylko 1 wpis (karta SD, jeśli jest dostępna, w przeciwnym razie wewnętrzna). Więcej na ten temat przeczytasz tutaj .

  public static boolean isSdCardOnDevice(Context context) {
    File[] storages = ContextCompat.getExternalFilesDirs(context, null);
    if (storages.length > 1 && storages[0] != null && storages[1] != null)
        return true;
    else
        return false;
}

w moim przypadku wystarczyło, ale nie zapominaj, że niektóre urządzenia z Androidem mogą mieć 2 karty SD, więc jeśli potrzebujesz ich wszystkich - dostosuj powyższy kod.

Kirill Karmazin
źródło
2
@RequiresApi(api = Build.VERSION_CODES.O)
private void showStorageVolumes() {
    StorageStatsManager storageStatsManager = (StorageStatsManager) getSystemService(Context.STORAGE_STATS_SERVICE);
    StorageManager storageManager = (StorageManager) getSystemService(Context.STORAGE_SERVICE);
    if (storageManager == null || storageStatsManager == null) {
        return;
    }
    List<StorageVolume> storageVolumes = storageManager.getStorageVolumes();
    for (StorageVolume storageVolume : storageVolumes) {
        final String uuidStr = storageVolume.getUuid();
        final UUID uuid = uuidStr == null ? StorageManager.UUID_DEFAULT : UUID.fromString(uuidStr);
        try {
            Log.d("AppLog", "storage:" + uuid + " : " + storageVolume.getDescription(this) + " : " + storageVolume.getState());
            Log.d("AppLog", "getFreeBytes:" + Formatter.formatShortFileSize(this, storageStatsManager.getFreeBytes(uuid)));
            Log.d("AppLog", "getTotalBytes:" + Formatter.formatShortFileSize(this, storageStatsManager.getTotalBytes(uuid)));
        } catch (Exception e) {
            // IGNORED
        }
    }
}

Klasa StorageStatsManager wprowadziła system Android O i nowszy, który może zapewnić bezpłatny i całkowity bajt w pamięci zewnętrznej / wewnętrznej. Aby uzyskać szczegółowe informacje o kodzie źródłowym, możesz przeczytać mój następujący artykuł. możesz użyć refleksji na niższych niż Android O.

https://medium.com/cashify-engineering/how-to-get-storage-stats-in-android-o-api-26-4b92eca6805b

Brijesh Gupta
źródło
2

Tak to zrobiłem ...

pamięć wewnętrzna Total

double totalSize = new File(getApplicationContext().getFilesDir().getAbsoluteFile().toString()).getTotalSpace();
double totMb = totalSize / (1024 * 1024);

Wolny rozmiar wewnętrzny

 double availableSize = new File(getApplicationContext().getFilesDir().getAbsoluteFile().toString()).getFreeSpace();
    double freeMb = availableSize/ (1024 * 1024);

Zewnętrzna pamięć wolna i całkowita

 long freeBytesExternal =  new File(getExternalFilesDir(null).toString()).getFreeSpace();
       int free = (int) (freeBytesExternal/ (1024 * 1024));
        long totalSize =  new File(getExternalFilesDir(null).toString()).getTotalSpace();
        int total= (int) (totalSize/ (1024 * 1024));
       String availableMb = free+"Mb out of "+total+"MB";
makvine
źródło
0

Jeśli chodzi o menorię zewnętrzną, jest inny sposób:
File external = Environment.getExternalStorageDirectory(); free:external.getFreeSpace(); total:external.getTotalSpace();

Edwarda Andersona
źródło
0

Po sprawdzeniu różnych rozwiązań napisz kod samodzielnie, to jest kompletny kod do znalezienia

  • Całkowita pamięć zewnętrzna
  • Wolna pamięć zewnętrzna
  • Używana pamięć zewnętrzna
  • Pamięć wewnętrzna TotaL
  • Używana pamięć wewnętrzna
  • Wolna pamięć wewnętrzna

'' ''

object DeviceMemoryUtil {
private const val error: String = "Something went wrog"
private const val noExternalMemoryDetected = "No external Storage detected"
private var totalExternalMemory: Long = 0
private var freeExternalMemory: Long = 0
private var totalInternalStorage: Long = 0
private var freeInternalStorage: Long = 0

/**
 * Checks weather external memory is available or not
 */
private fun externalMemoryAvailable(): Boolean {
    return Environment.getExternalStorageState() ==
            Environment.MEDIA_MOUNTED
}

/**
 *Gives total external memory
 * @return String Size of external memory
 * @return Boolean True if memory size is returned
 */
fun getTotalExternalMemorySize(): Pair<String?, Boolean> {
    val dirs: Array<File> = ContextCompat.getExternalFilesDirs(CanonApplication.getCanonAppInstance(), null)
    return if (externalMemoryAvailable()) {
        if (dirs.size > 1) {
            val stat = StatFs(dirs[1].path)
            val blockSize = stat.blockSizeLong
            val totalBlocks = stat.blockCountLong
            var totalExternalSize = totalBlocks * blockSize
            totalExternalMemory = totalExternalSize
            Pair(formatSize(totalExternalSize), true)
        } else {
            Pair(error, false)
        }
    } else {
        Pair(noExternalMemoryDetected, false)
    }
}

/**
 * Gives free external memory size
 * @return String Size of free external memory
 * @return Boolean True if memory size is returned
 */
fun getAvailableExternalMemorySize(): Pair<String?, Boolean> {
    val dirs: Array<File> = ContextCompat.getExternalFilesDirs(CanonApplication.getCanonAppInstance(), null)
    if (externalMemoryAvailable()) {
        return if (dirs.size > 1) {
            val stat = StatFs(dirs[1].path)
            val blockSize = stat.blockSizeLong
            val availableBlocks = stat.availableBlocksLong
            var freeExternalSize = blockSize * availableBlocks
            freeExternalMemory = freeExternalSize
            Pair(formatSize(freeExternalSize), true)
        } else {
            Pair(error, false)
        }
    } else {
        return Pair(noExternalMemoryDetected, false)
    }
}

/**
 * Gives used external memory size
 *  @return String Size of used external memory
 * @return Boolean True if memory size is returned
 */
fun getUsedExternalMemorySize(): Pair<String?, Boolean> {
    return if (externalMemoryAvailable()) {
        val totalExternalSize = getTotalExternalMemorySize()
        val freeExternalSize = getAvailableExternalMemorySize()
        if (totalExternalSize.second && freeExternalSize.second) {
            var usedExternalVolume = totalExternalMemory - freeExternalMemory
            Pair(formatSize(usedExternalVolume), true)
        } else {
            Pair(error, false)
        }
    } else {
        Pair(noExternalMemoryDetected, false)
    }
}

/**
 *Formats the long to size of memory in gb,mb etc.
 * @param size Size of memory
 */
fun formatSize(size: Long): String? {
    return android.text.format.Formatter.formatFileSize(CanonApplication.getCanonAppInstance(), size)
}

/**
 * Gives total internal memory size
 *  @return String Size of total internal memory
 * @return Boolean True if memory size is returned
 */
fun getTotalInternalStorage(): Pair<String?, Boolean> {
    if (showStorageVolumes()) {
        return Pair(formatSize(totalInternalStorage), true)
    } else {
        return Pair(error, false)
    }

}

/**
 * Gives free or available internal memory size
 *  @return String Size of free internal memory
 * @return Boolean True if memory size is returned
 */
fun getFreeInternalStorageVolume(): Pair<String?, Boolean> {
    return if (showStorageVolumes()) {
        Pair(formatSize(freeInternalStorage), true)
    } else {
        Pair(error, false)
    }
}

/**
 *For calculation of internal storage
 */
private fun showStorageVolumes(): Boolean {
    val storageManager = CanonApplication.canonApplicationInstance.applicationContext.getSystemService(Context.STORAGE_SERVICE) as StorageManager
    val storageStatsManager = CanonApplication.canonApplicationInstance.applicationContext.getSystemService(Context.STORAGE_STATS_SERVICE) as StorageStatsManager
    if (storageManager == null || storageStatsManager == null) {
        return false
    }
    val storageVolumes: List<StorageVolume> = storageManager.storageVolumes
    for (storageVolume in storageVolumes) {
        var uuidStr: String? = null
        storageVolume.uuid?.let {
            uuidStr = it
        }
        val uuid: UUID = if (uuidStr == null) StorageManager.UUID_DEFAULT else UUID.fromString(uuidStr)
        return try {
            freeInternalStorage = storageStatsManager.getFreeBytes(uuid)
            totalInternalStorage = storageStatsManager.getTotalBytes(uuid)
            true
        } catch (e: Exception) {
            // IGNORED
            false
        }
    }
    return false
}

fun getTotalInternalExternalMemory(): Pair<Long?, Boolean> {
    if (externalMemoryAvailable()) {
        if (getTotalExternalMemorySize().second) {
            if (getTotalInternalStorage().second) {
                return Pair(totalExternalMemory + totalInternalStorage, true)
            } else {
                return Pair(0, false)
            }
        }
        return Pair(0, false)
    } else {
        if (getTotalInternalStorage().second) {
            return Pair(totalInternalStorage, true)
        } else {
            return Pair(0, false)
        }
    }

}

fun getTotalFreeStorage(): Pair<Long,Boolean> {
    if (externalMemoryAvailable()){
        if(getFreeInternalStorageVolume().second){
            getFreeInternalStorageVolume()
            getAvailableExternalMemorySize()
                return Pair(freeExternalMemory + freeInternalStorage,true)
        }
        else{
            return Pair(0,false)
        }
    }
    else {
        if (getFreeInternalStorageVolume().second){
            getFreeInternalStorageVolume()
            return Pair(freeInternalStorage,true)
        }
      else{
            return Pair(0,false)
        }
    }

}}
Sahil Bansal
źródło