¿Cómo puedo comprobar el espacio disponible en un dispositivo Android? ¿En una tarjeta SD? [duplicate]

¿Cómo verifico cuánto espacio (en MB o GB) queda en el dispositivo Android? Estoy usando Java y Android SDK 2.0.1.

¿Hay algún servicio del sistema que exponga algo como esto?

La respuesta de Yaroslav dará el tamaño de la tarjeta SD, no el espacio disponible. estadísticas getAvailableBlocks() devolverá la cantidad de bloques que aún son accesibles para los programas normales. Aquí está la función que estoy usando:

public static float megabytesAvailable(File f) {
    StatFs stat = new StatFs(f.getPath());
    long bytesAvailable = (long)stat.getBlockSize() * (long)stat.getAvailableBlocks();
    return bytesAvailable / (1024.f * 1024.f);
}

El código anterior hace referencia a algunas funciones obsoletas a partir del 13 de agosto de 2014. A continuación reproduzco una versión actualizada:

public static float megabytesAvailable(File f) {
    StatFs stat = new StatFs(f.getPath());
    long bytesAvailable = 0;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2)
        bytesAvailable = (long) stat.getBlockSizeLong() * (long) stat.getAvailableBlocksLong();
    else
        bytesAvailable = (long) stat.getBlockSize() * (long) stat.getAvailableBlocks();
    return bytesAvailable / (1024.f * 1024.f);
}

Intentar este código:

StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());

long bytesAvailable = (long)stat.getBlockSize() *(long)stat.getBlockCount();
long megAvailable   = bytesAvailable / 1048576;

System.out.println("Megs: " + megAvailable);

Explicación

getBlockCount() – tamaño de retorno de la tarjeta SD;

getAvailableBlocks() – devuelve la cantidad de bloques que aún son accesibles para los programas normales (gracias Joe)

He diseñado algunas funciones listas para usar para obtener el espacio disponible en diferentes unidades. Puede usar estos métodos simplemente copiando cualquiera de ellos en su proyecto.

/**
 * @return Number of bytes available on External storage
 */
public static long getAvailableSpaceInBytes() {
    long availableSpace = -1L;
    StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
    availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();

    return availableSpace;
}


/**
 * @return Number of kilo bytes available on External storage
 */
public static long getAvailableSpaceInKB() {
    final long SIZE_KB = 1024L;
    long availableSpace = -1L;
    StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
    availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
    return availableSpace/SIZE_KB;
}


/**
 * @return Number of Mega bytes available on External storage
 */
public static long getAvailableSpaceInMB() {
    final long SIZE_KB = 1024L;
    final long SIZE_MB = SIZE_KB * SIZE_KB;
    long availableSpace = -1L;
    StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
    availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
    return availableSpace/SIZE_MB;
}


/**
 * @return Number of gega bytes available on External storage
 */
public static long getAvailableSpaceInGB() {
    final long SIZE_KB = 1024L;
    final long SIZE_GB = SIZE_KB * SIZE_KB * SIZE_KB;
    long availableSpace = -1L;
    StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
    availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
    return availableSpace/SIZE_GB;
}

Según esta respuesta, agregaron soporte para la versión de Android

public static float megabytesAvailable(File file) {
    StatFs stat = new StatFs(file.getPath());
    long bytesAvailable;
    if(Build.VERSION.SDK_INT >= 18) {
        bytesAvailable = getAvailableBytes(stat);
    }
    else {
        // noinspection deprecation
        bytesAvailable = stat.getBlockSize() * stat.getAvailableBlocks();
    }

    return bytesAvailable / (1024.f * 1024.f);
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static long getAvailableBytes(StatFs stat) {
    return stat.getBlockSizeLong() * stat.getAvailableBlocksLong();
}

Se introdujeron nuevos métodos desde la versión 18 de la API.

Usé algo así para la estimación del tamaño de caché de disco grande (para el caché de descarga de Picasso OkHttp). El método auxiliar era así:

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

Además, si desea verificar el espacio disponible en la memoria interna, use:

File path = Environment.getDataDirectory();
StatFs stat = new StatFs(path.getPath());

…

Google tiene información sobre esto en la página de inicio. – Ver Consulta de Espacio Libre. Dicen que puedes comprobar el espacio disponible por getFreeSpace() pero afirman que esto es inexacto y debe esperar un poco menos de espacio libre que esto. Ellos dicen:

Si el número devuelto es unos MB más que el tamaño de los datos que desea guardar, o si el sistema de archivos está lleno en menos del 90 %, probablemente sea seguro continuar. De lo contrario, probablemente no debería escribir en el almacenamiento.

También dan el consejo de que a menudo es más útil no revisar el espacio libre en absoluto y simplemente try catch por un error:

No es necesario que verifique la cantidad de espacio disponible antes de guardar su archivo. En su lugar, puede intentar escribir el archivo de inmediato y luego capturar una IOException si ocurre una. Es posible que deba hacer esto si no sabe exactamente cuánto espacio necesita. Por ejemplo, si cambia la codificación del archivo antes de guardarlo al convertir una imagen PNG a JPEG, no sabrá el tamaño del archivo de antemano.

Recomendaría que solo para tamaños de archivo muy grandes, debe verificar el almacenamiento disponible de antemano para que no pierda tiempo descargando o creando un archivo que, obviamente, es demasiado grande para contener. En cualquiera de los casos, siempre debe usar try catch por lo tanto, creo que el único argumento para verificar el espacio libre disponible de antemano es si el uso innecesario de recursos y tiempo es demasiado.