Comment vérifier l'espace disponible sur un appareil Android ? sur une carte SD ?

Question

Comment vérifier combien de Mo ou de Go il reste sur l'appareil Android ? J'utilise JAVA et Android SDK 2.0.1.

Existe-t-il un service système qui pourrait exposer quelque chose comme ça ?

Answer 1

De nouvelles méthodes ont été introduites depuis la version 18 de l'API.

J'ai utilisé quelque chose comme ça pour l'estimation de la taille du cache des gros disques (pour le cache du téléchargeur OkHttp de Picasso). La méthode Helper était comme ça :

private static final String BIG_CACHE_PATH = "my-cache-dir";
private static final float  MAX_AVAILABLE_SPACE_USE_FRACTION = 0.9f;
private static final float  MAX_TOTAL_SPACE_USE_FRACTION     = 0.25f;

static File createDefaultCacheDirExample(Context context) {
    File cache = new File(context.getApplicationContext().getCacheDir(), BIG_CACHE_PATH);
    if (!cache.exists()) {
        cache.mkdirs();
    }
    return cache;
}

/**
 * Calculates minimum of available or total fraction of disk space
 * 
 * @param dir
 * @return space in bytes
 */
@SuppressLint("NewApi")
static long calculateAvailableCacheSize(File dir) {
    long size = 0;
    try {
        StatFs statFs = new StatFs(dir.getAbsolutePath());
        int sdkInt = Build.VERSION.SDK_INT;
        long totalBytes;
        long availableBytes;
        if (sdkInt < Build.VERSION_CODES.JELLY_BEAN_MR2) {
            int blockSize = statFs.getBlockSize();
            availableBytes = ((long) statFs.getAvailableBlocks()) * blockSize;
            totalBytes = ((long) statFs.getBlockCount()) * blockSize;
        } else {
            availableBytes = statFs.getAvailableBytes();
            totalBytes = statFs.getTotalBytes();
        }
        // Target at least 90% of available or 25% of total space
        size = (long) Math.min(availableBytes * MAX_AVAILABLE_SPACE_USE_FRACTION, totalBytes * MAX_TOTAL_SPACE_USE_FRACTION);
    } catch (IllegalArgumentException ignored) {
        // ignored
    }
    return size;
}

Answer 2

Google fournit des informations à ce sujet sur la page "Démarrage". - Voir Requête d'espace libre. Ils disent que vous pouvez soit vérifier l'espace disponible en getFreeSpace() mais ils déclarent que cela est inexact et que vous devez vous attendre à un peu moins d'espace libre que cela. Ils disent :

Si le nombre retourné est supérieur de quelques Mo à la taille des données que vous voulez sauvegarder, ou si le système de fichiers est rempli à moins de 90 %, vous pouvez probablement continuer. Sinon, vous ne devriez probablement pas écrire dans le stockage.

Ils donnent également le conseil qu'il est souvent plus utile de ne pas vérifier l'espace libre du tout et de juste try catch pour une erreur :

Vous n'êtes pas tenu de vérifier la quantité d'espace disponible avant d'enregistrer votre fichier. Vous pouvez essayer d'écrire le fichier tout de suite, puis attraper une IOException si elle se produit. Vous devrez peut-être procéder ainsi si vous ne savez pas exactement de combien d'espace vous avez besoin. Par exemple, si vous modifiez l'encodage du fichier avant de l'enregistrer en convertissant une image PNG en JPEG, vous ne connaîtrez pas la taille du fichier à l'avance.

Je vous recommande, uniquement pour les fichiers de très grande taille, de vérifier au préalable l'espace de stockage disponible afin de ne pas perdre de temps à télécharger ou à créer un fichier qui est manifestement trop volumineux. Dans tous les cas, vous devez toujours utiliser try catch Je pense donc que le seul argument en faveur de la vérification préalable de l'espace libre disponible est que l'utilisation inutile de ressources et de temps est trop importante.

Answer 3

J'espère que ce code pourra aider d'autres personnes. Testé, il fonctionne bien. Merci au membre ci-dessus pour le clarifier.

/**
 * Get the free disk available space in boolean to download requested file 
 * 
 * @return boolean value according to size availability
 */

protected static boolean isMemorySizeAvailableAndroid(long download_bytes, boolean isExternalMemory) {
    boolean isMemoryAvailable = false;
    long freeSpace = 0;

    // if isExternalMemory get true to calculate external SD card available size
    if(isExternalMemory){
        try {
            StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
            freeSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
            if(freeSpace > download_bytes){
                isMemoryAvailable = true;
            }else{
                isMemoryAvailable = false;
            }
        } catch (Exception e) {e.printStackTrace(); isMemoryAvailable = false;}
    }else{
        // find phone available size
        try {
            StatFs stat = new StatFs(Environment.getDataDirectory().getPath());
            freeSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
            if(freeSpace > download_bytes){
                isMemoryAvailable = true;
            }else{
                isMemoryAvailable = false;
            }
        } catch (Exception e) {e.printStackTrace(); isMemoryAvailable = false;}
    }

    return isMemoryAvailable;
}

Answer 4

public String TotalExtMemory()
{
    StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath());   
    int Total = (statFs.getBlockCount() * statFs.getBlockSize()) / 1048576;

    String strI = Integer.toString(Total);
    return strI;
}

public String FreeExtMemory()
{
    StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath());
    int Free  = (statFs.getAvailableBlocks() * statFs.getBlockSize()) / 1048576;
    String strI = Integer.toString(Free);
    return strI;
}

public String BusyExtMemory()
{
    StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath());   
    int Total = (statFs.getBlockCount() * statFs.getBlockSize()) / 1048576;
    int Free  = (statFs.getAvailableBlocks() * statFs.getBlockSize()) / 1048576;
    int Busy  = Total - Free;
    String strI = Integer.toString(Busy);
    return strI;
}