Comment obtenir la taille d'une carte SD de stockage externe (avec une carte SD montée) ?

Question

Lien :J'ai travaillé sur la base de ce lien

J'ai ajouté cette ligne pour trouver la taille (interne et externe),

return availableExternalMemorySize/(1024*1024);

J'ai testé sur ma tablette. J'obtiens la taille de la carte SD interne et externe comme suit,

Dans la mémoire interne :

1. Mémoire totale --1007
2. Mémoire disponible --683

Dans Stockage externe :

1. Mémoire totale -- 1763
2. Mémoire disponible -- 1554

Mais dans Tablet, j'ai vu des décors. La taille du stockage externe est de 8 Go. Mais il m'indique 1,7 Go environ lorsque j'ai testé par programme.

Quelle est la procédure à suivre pour déterminer la taille d'un espace de stockage externe ?

Answer 1

Pour que l'espace "libre" disponible sur la carte SD externe affiche un nombre correspondant à celui de Menu->Réglages->Carte SD et stockage du téléphone, utilisez le code suivant :

StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
double sdAvailSize = (double)stat.getAvailableBlocks()
                   * (double)stat.getBlockSize();
//One binary gigabyte equals 1,073,741,824 bytes.
double gigaAvailable = sdAvailSize / 1073741824;

Voici comment obtenir les tailles de stockage interne :

 StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());        
 long blockSize = statFs.getBlockSize();
 long totalSize = statFs.getBlockCount()*blockSize;
 long availableSize = statFs.getAvailableBlocks()*blockSize;
 long freeSize = statFs.getFreeBlocks()*blockSize;

Voici comment obtenir les tailles de stockage externe (taille de la carte SD) :

 StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath());        
 long blockSize = statFs.getBlockSize();
 long totalSize = statFs.getBlockCount()*blockSize;
 long availableSize = statFs.getAvailableBlocks()*blockSize;
 long freeSize = statFs.getFreeBlocks()*blockSize;

---

Note brève

Blocs libres :

Le nombre total de bl libres sur le système de fichiers, y compris les blocs réservés (qui ne sont pas disponibles pour les applications normales).

Blocs disponibles :

Le nombre de blocs t système de fichiers et disponibles pour les applications.

---

Voici comment détecter si la carte SD est montée :

 String state = Environment.getExternalStorageState();
 if (Environment.MEDIA_MOUNTED.equals(state)) 
 {
   // We can read and write the media    
 } 
 else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) 
 {
    // We can only read the media     
 } 
 else 
 {
    // No external media
 }

Documentation pertinente : http://developer.Android.com/reference/Android/os/StatFs.html

Answer 2

 Use the
following code
it may
help

public void getInternalmemorySize() {
    StatFs stat_fs = new StatFs(Environment.getExternalStorageDirectory().getPath());
    double avail_sd_space = (double) stat_fs.getAvailableBlocksLong() * (double) stat_fs.getBlockSizeLong();
    double GB_Available = (avail_sd_space / 1073741824);
    double GBTotal = ((double) stat_fs.getBlockCountLong() * (double) stat_fs.getBlockSizeLong()) / 1073741824;
    SDCardCheck();
    Log.e("Memory", "Available MB  Internal: " + GB_Available + "---" + GBTotal);
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
static String getExternalSdCardSize() {
    File storage = new File("/storage");
    String external_storage_path = "";
    String size = "";

    if (storage.exists()) {
        File[] files = storage.listFiles();

        for (File file : files) {
            if (file.exists()) {
                try {
                    if (Environment.isExternalStorageRemovable(file)) {
                        // storage is removable
                        external_storage_path = file.getAbsolutePath();
                        break;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.e("TAG", e.toString());
                }
            }
        }
    }

    if (!external_storage_path.isEmpty()) {
        File external_storage = new File(external_storage_path);
        if (external_storage.exists()) {
            size = totalSize(external_storage);
        }
    }
    return size;
}

private static String totalSize(File file) {
    StatFs stat = new StatFs(file.getPath());
    long blockSize, totalBlocks;
    long avaiblockSize, availableBlocks;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
        blockSize = stat.getBlockSizeLong();
        totalBlocks = stat.getBlockCountLong();
        avaiblockSize = stat.getAvailableBlocksLong();
        availableBlocks = stat.getBlockSizeLong();
    } else {
        blockSize = stat.getBlockSize();
        totalBlocks = stat.getBlockCount();
        avaiblockSize = stat.getAvailableBlocks();
        availableBlocks = stat.getBlockSize();
    }
    Log.e("Memory", "Memory--external--" + (double) (blockSize * totalBlocks) / 1073741824 + "---" + (double) (avaiblockSize * availableBlocks) / 1073741824);
    return formatSize(totalBlocks * blockSize);
}

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

    if (size >= 1024) {
        suffix = "KB";
        size /= 1024;
        if (size >= 1024) {
            suffix = "MB";
            size /= 1024;
        }
    }
    size = size / 1024;
    StringBuilder resultBuilder = new StringBuilder(Long.toString(size));

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

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

Ther is
some calculation
behalf of
these Methods.

StructStatVfs[
f_bavail=81523,
f_bfree=81523,
f_blocks=242304,
f_bsize=32768,
f_favail=0,
f_ffree=0,
f_files=0,
f_flag=1038,
f_frsize=32768,
f_fsid=0,
f_namemax=1530
        ]

StructStatVfs[
f_bavail=1633375,
f_bfree=1641567,
f_blocks=3134770,
f_bsize=4096,
f_favail=767939,
f_ffree=767939,
f_files=804672,
f_flag=1038,
f_frsize=4096,
f_fsid=0,
f_namemax=255
        ]

Internal-

        3134770*4096/1024*1024*1024=11.957.10 1633375*4096/1024*1024*1024=6.23

External-
        81523*32768/1024*1024*1024=2.487 242304*32768/1024*1024*1024=7.39

Answer 3

Afin de tenir compte de la dépréciation et de la disponibilité croisée, j'ai créé ces méthodes.

public static long sdCardFree_bytes() {
    File   path        = Environment.getExternalStorageDirectory();
    StatFs stat        = new StatFs(path.getPath());
    long   free_memory = 0; //return value is in bytes

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
        free_memory = stat.getAvailableBlocksLong() * stat.getBlockSizeLong();
    } else {
        free_memory = stat.getAvailableBlocks() * stat.getBlockSize();
    }

    return free_memory;
}

public static long sdCardUsed_bytes() {

    File   path        = Environment.getExternalStorageDirectory();
    StatFs stat        = new StatFs(path.getPath());
    long   free_memory = 0;

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
        free_memory = (stat.getBlockCountLong() - stat.getAvailableBlocksLong()) * stat.getBlockSizeLong(); //return value is in bytes
    } else {
        free_memory = (stat.getBlockCount() - stat.getAvailableBlocks()) * stat.getBlockSize(); //return value is in bytes
    }

    return free_memory;
}

public static long sdCardTotal_bytes() {

    File   path        = Environment.getExternalStorageDirectory();
    StatFs stat        = new StatFs(path.getPath());
    long   free_memory = 0;

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
        free_memory = stat.getBlockCountLong() * stat.getBlockSizeLong(); //return value is in bytes
    } else {
        free_memory = stat.getBlockCount() * stat.getBlockSize(); //return value is in bytes
    }

    return free_memory;
}

Answer 4

Vous pouvez utiliser getTotalSpace () , getFreeSpace () ou getUsableSpace () https://developer.Android.com/reference/java/io/File.html

import java.io.File;
import android.util.Log;
....
File f = getMyFile();
Log.d("MyApp", f.getTotalSpace()+"");
....