Android erhält freie Größe des internen / externen Speichers

98

Ich möchte die Größe des freien Speichers im internen / externen Speicher meines Geräts programmgesteuert ermitteln. Ich benutze diesen Code:

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);

und das Ergebnis, das ich bekomme, ist:

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

Das Problem ist, dass ich den freien Speicher von SdCard bekommen möchte, der gerade ist 1,96GB. Wie kann ich diesen Code reparieren, um die freie Größe zu erhalten?

Android-Droid
quelle
Ab API-Level 18 haben sie die Methode so umbenannt, dass sie mit Long endet. Wahrscheinlich müssten Sie vorher eine Überprüfung der API-Ebene hinzufügen
Jayshil Dave
Alle Lösung Ich habe versucht, niemanden zu arbeiten, wenn ich als interner Speicher formatiere ... können Sie mir bitte, wie dies zu erreichen ist?
Yogesh Rathi

Antworten:

182

Unten ist der Code für Ihren Zweck:

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();
    }

RAM-Größe abrufen

ActivityManager actManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
MemoryInfo memInfo = new ActivityManager.MemoryInfo();
actManager.getMemoryInfo(memInfo);
long totalMemory = memInfo.totalMem;
Dinesh Prajapati
quelle
2
getBlockSize()und getBlockCountsind veraltet.
Nima G
2
@DineshPrajapati Vielen Dank für die Antwort. Ich habe die Frage: Wenn ich Environment.getRootDirectory () anstelle von Environment.getDataDirectory für die Berechnung des internen Speichers verwende, erhalte ich eine Ausgabe. Dies bezieht sich auf den internen Speicher anderer Speicher.
AK Joshi
3
@ DineshPrajapati .. Getestet auf MOTO G2 Falsche Daten für externen Speicher erhalten
AK Joshi
1
Verwenden Sie Long am Ende für neuere API-Levels (> 18)
Gun2sh
1
Vielen Dank für den Wissensaustausch
Kishan Soni
40

So habe ich es gemacht:

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
quelle
2
aber das ist verdorben :(
abbasalim
@ ArMo372, habt ihr den Ersatzcode dafür herausgefunden?
SimpleCoder
3
Einfach ersetzen getBlockSizeund getAvailableBlocksmit getBlockSizeLongund getAvailableBlocksLong.
smg
1
Dies ist nicht der richtige verfügbare Platz. Dies wird 1141 statt 1678 @smg
1
Lösung funktioniert nicht, wenn ich als internen Speicher formatiere ... können Sie mir bitte, wie dies erreicht werden kann
Yogesh Rathi
27

Seit API 9 können Sie Folgendes tun:

long freeBytesInternal = new File(ctx.getFilesDir().getAbsoluteFile().toString()).getFreeSpace();
long freeBytesExternal = new File(getExternalFilesDir(null).toString()).getFreeSpace();
Tzoiker
quelle
2
File.getUsableSpace () ist wahrscheinlich besser, weil Sie wahrscheinlich nicht als root ausgeführt werden.
Mark
Das File.getUsableSpace()scheint eine einfachere Methode zu sein, als sie zu verwenden StatFs. Warum sollte ich StatFs@MarkCarter verwenden?
StuStirling
1
@ DiscoS2 Sie statfs verwenden würden , wenn Ihr minSdkVersion weniger als 9.
Mark
1
Wie würden Sie auch Speicheränderungen überwachen?
Android-Entwickler
24

Um alle verfügbaren Speicherordner (einschließlich SD-Karten) abzurufen, erhalten Sie zunächst die Speicherdateien:

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

Dann können Sie die verfügbare Größe von jedem von diesen erhalten.

Es gibt drei Möglichkeiten, dies zu tun:

API 8 und niedriger:

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

API 9 und höher:

long availableSizeInBytes=file.getFreeSpace();

API 18 und höher (nicht erforderlich, wenn die vorherige in Ordnung ist):

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

Um eine schöne formatierte Zeichenfolge von dem zu erhalten, was Sie jetzt haben, können Sie Folgendes verwenden:

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

oder Sie können dies verwenden, wenn Sie die genaue Bytennummer sehen möchten, aber schön:

NumberFormat.getInstance().format(availableSizeInBytes);

Beachten Sie, dass der interne Speicher meines Erachtens mit dem ersten externen Speicher identisch sein kann, da der erste der emulierte ist.


BEARBEITEN: Wenn Sie StorageVolume unter Android Q und höher verwenden, ist es meiner Meinung nach möglich, den freien Speicherplatz von jedem zu nutzen, indem Sie Folgendes verwenden:

    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)}")
        }
    }

Ich bin mir nicht sicher , ob dies richtig ist, und ich kann nicht einen Weg finden , die Gesamtgröße der einzelnen zu bekommen, so dass ich darüber schrieb hier und fragte darüber hier .

Android-Entwickler
quelle
1
Wie kann ich auf Geräten mit API 23 freien Speicherplatz auf einer austauschbaren SD-Karte (oder einem USB-OTG-Flash-Laufwerk) erhalten? Neue StatFs (file.getPath ()). getAvailableBytes () oder file.getUsableSpace () liefern 972546048 Bytes unabhängig von der tatsächlichen Speichergröße auf Nexus 5 (Marshmallow 6.0.1).
isabsent
@isabsent Nexus 5 hat keinen SD-Kartensteckplatz. Wie hast du das überprüft?
Android-Entwickler
Ich habe es mit USB OTG Flash-Laufwerk überprüft.
Isabsent
@isabsent Ich habe es nie benutzt. Es tut uns leid. Funktioniert es gut mit API 22 und niedriger?
Android-Entwickler
1
@Smeet Ist es möglich, dass Sie es auf Android 6 oder höher versuchen? Wenn ja, ist es vielleicht ein Problem wie das folgende: code.google.com/p/android/issues/detail?id=200326
Android-Entwickler
7

Probieren Sie dieses einfache Snippet aus

    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
quelle
Danke, aber ich habe den java.lang.ArrayIndexOutOfBoundsException: length=5; index=-2147483648Fehler, scheint das digitGroupsErgebnis -2147483648 zu sein.
Acuna
Lösung funktioniert nicht, wenn ich als internen Speicher formatiere ... können Sie mir bitte, wie dies erreicht werden kann
Yogesh Rathi
6

Es ist sehr einfach, den verfügbaren Speicher zu ermitteln, wenn Sie sowohl einen internen als auch einen externen Speicherpfad erhalten. Auch der externe Speicherpfad des Telefons ist wirklich sehr einfach herauszufinden

Environment.getExternalStorageDirectory (). GetPath ();

Ich konzentriere mich also nur darauf, wie man die Pfade des externen Wechselspeichers wie Wechseldatenträger, USB OTG (nicht getestetes USB OTG, da ich kein USB OTG habe) herausfindet.

Die folgende Methode enthält eine Liste aller möglichen externen Wechselspeicherpfade.

 /**
     * 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
quelle
Wie ich mich erinnere, funktioniert die Verwendung konstanter Namen für die Pfadbehandlung auf einigen Geräten möglicherweise nicht, da einige möglicherweise eigene Pfade haben. Ich hoffe das ist nicht der Fall. +1 für den Aufwand.
Android-Entwickler
1
@androiddeveloper Vielen Dank für die Abstimmung. Ich benötige Unterstützung von allen, um diesen Code auf Ihrem Gerät zu testen, da ich nicht alle Geräte habe, sondern auf 4 verschiedenen Geräten getestet habe und einwandfrei funktioniert. Bitte kommentieren Sie hier funktioniert nicht in einem Handy.
Smeet
Lösung funktioniert nicht, wenn ich als internen Speicher formatiere ... können Sie mir bitte, wie dies erreicht werden kann
Yogesh Rathi
4

Schnelle Ergänzung zum Thema Externer Speicher

Lassen Sie sich nicht durch den Methodennamen externalMemoryAvailable()in Dinesh Prajapatis Antwort verwirren .

Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())Gibt den aktuellen Status des Speichers an, wenn das Medium vorhanden ist und an seinem Einhängepunkt mit Lese- / Schreibzugriff bereitgestellt wird. Sie werden truesogar auf Geräten ohne SD-Karten wie Nexus 5 arbeiten. Dennoch ist es eine "Must-Have" -Methode, bevor Operationen mit Speicher ausgeführt werden.

Um zu überprüfen, ob sich auf Ihrem Gerät eine SD-Karte befindet, können Sie die Methode verwenden ContextCompat.getExternalFilesDirs()

Es werden keine vorübergehenden Geräte wie USB-Sticks angezeigt.

Beachten Sie auch, dass ContextCompat.getExternalFilesDirs()unter Android 4.3 und niedriger immer nur 1 Eintrag zurückgegeben wird (SD-Karte, falls verfügbar, andernfalls intern). Sie können mehr darüber lesen Sie hier .

  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;
}

In meinem Fall war es genug, aber vergessen Sie nicht, dass einige der Android-Geräte möglicherweise 2 SD-Karten haben. Wenn Sie also alle benötigen, passen Sie den obigen Code an.

Kirill Karmazin
quelle
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
        }
    }
}

In der StorageStatsManager-Klasse wurde Android O und höher eingeführt, mit dem Sie kostenloses und vollständiges Byte im externen / internen Speicher erhalten. Ausführliche Informationen zum Quellcode finden Sie in meinem folgenden Artikel. Sie können Reflection für weniger als Android O verwenden

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

Brijesh Gupta
quelle
2

So habe ich es gemacht ..

interner Gesamtspeicher

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

Interne freie Größe

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

Externer freier und Gesamtspeicher

 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
quelle
0

In Bezug auf die äußere Menory gibt es einen anderen Weg:
File external = Environment.getExternalStorageDirectory(); free:external.getFreeSpace(); total:external.getTotalSpace();

Edward Anderson
quelle
0

Nachdem ich verschiedene Lösungen überprüft habe, schreibe ich selbst Code. Dies ist der vollständige Code zum Finden

  • Gesamter externer Speicher
  • Freier externer Speicher
  • Verwendeter externer Speicher
  • TotaL Interner Speicher
  • Verwendeter interner Speicher
  • Freier interner Speicher

'' ''

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
quelle