android - liberar - memoria interna llena y no tengo nada

Obtenga espacio libre en la memoria interna

Question

¿Es posible obtener la cantidad de memoria libre en un dispositivo Android (no en la tarjeta SD) a través de Android SDK?

¿Si es así, cómo?

Answer 1

En dispositivos donde el tamaño de la memoria interna es muy grande, no funciona porque el valor int es demasiado pequeño. Por ejemplo en Motorola xum no funciona. Tienes que usar algo como esto:

int freeSpaceInKilobytes = availableBlocks * (blockSizeInBytes / 1024);

Answer 2

Existen algunos métodos que Google dejó en desuso desde 2013 y es posible que cambie estos métodos (solo API 18+):

• getAvailableBlocks() para getAvailableBlocksLong()
• getBlockCount() a getBlockCountLong()
• getBlockSize() para getBlockSizeLong()
• getFreeBlocks() para getFreeBlocksLong()

Answer 3

Parece que la clase StatFs podría ser lo que necesitas usar. No estoy seguro de qué ruta se consideraría la raíz del dispositivo, pero creo que el resultado sería el mismo independientemente del directorio, siempre que sea parte del almacenamiento interno. Algo como esto puede funcionar:

StatFs stats = new StatFs("/data");
int availableBlocks = stats.getAvailableBlocks();
int blockSizeInBytes = stats.getBlockSize();
int freeSpaceInBytes = availableBlocks * blockSizeInBytes;

Si nada más, la clase StatFs debería darle un buen comienzo sobre dónde buscar.

Answer 4

Por favor, consulte este enlace: Android obtener tamaño libre de la memoria interna / externa Esto podría ayudar. Aquí, todo se explica de una manera agradable.

Answer 5

this publicación podría encajar bien en tu pregunta.

también revisa este hilo . hay tanta información aquí en SO.

busqué en Google un poco y aquí está la solución (que se encuentra en android git )

File path = Environment.getDataDirectory();
StatFs stat = new StatFs(path.getPath());
long blockSize = stat.getBlockSize();
long availableBlocks = stat.getAvailableBlocks();
return Formatter.formatFileSize(this, availableBlocks * blockSize);

Answer 6

/**
 * @return Number of bytes available on internal storage
 */
public static long getInternalAvailableSpace() {
    long availableSpace = -1L;
    try {StatFs stat = new StatFs(Environment.getDataDirectory()
            .getPath());
        stat.restat(Environment.getDataDirectory().getPath());
        availableSpace = (long) stat.getAvailableBlocks() * (long) stat.getBlockSize();
    } catch (Exception e) {
        e.printStackTrace();
    }

    return availableSpace;
}

Answer 7

/*************************************************************************************************
Returns size in bytes.

If you need calculate external memory, change this: 
    StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());
to this: 
    StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath());        
**************************************************************************************************/
    public long TotalMemory()
    {
        StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());   
        long   Total  = ( (long) statFs.getBlockCount() * (long) statFs.getBlockSize());
        return Total;
    }

    public long FreeMemory()
    {
        StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());
        long   Free   = (statFs.getAvailableBlocks() * (long) statFs.getBlockSize());
        return Free;
    }

    public long BusyMemory()
    {
        StatFs statFs = new StatFs(Environment.getRootDirectory().getAbsolutePath());   
        long   Total  = ((long) statFs.getBlockCount() * (long) statFs.getBlockSize());
        long   Free   = (statFs.getAvailableBlocks()   * (long) statFs.getBlockSize());
        long   Busy   = Total - Free;
        return Busy;
    }

Conversión de bytes a formato legible para el ser humano (como 1 Mb, 1 Gb)

    public static String floatForm (double d)
    {
       return new DecimalFormat("#.##").format(d);
    }


    public static String bytesToHuman (long size)
    {
        long Kb = 1  * 1024;
        long Mb = Kb * 1024;
        long Gb = Mb * 1024;
        long Tb = Gb * 1024;
        long Pb = Tb * 1024;
        long Eb = Pb * 1024;

        if (size <  Kb)                 return floatForm(        size     ) + " byte";
        if (size >= Kb && size < Mb)    return floatForm((double)size / Kb) + " Kb";
        if (size >= Mb && size < Gb)    return floatForm((double)size / Mb) + " Mb";
        if (size >= Gb && size < Tb)    return floatForm((double)size / Gb) + " Gb";
        if (size >= Tb && size < Pb)    return floatForm((double)size / Tb) + " Tb";
        if (size >= Pb && size < Eb)    return floatForm((double)size / Pb) + " Pb";
        if (size >= Eb)                 return floatForm((double)size / Eb) + " Eb";

        return "???";
    }