java - studio - sviluppare app android pdf




Come controllare lo spazio disponibile sul dispositivo Android? sulla scheda SD? (6)

Questa domanda ha già una risposta qui:

Come posso verificare quanto MB o GB sono rimasti sul dispositivo Android? Sto usando JAVA e Android SDK 2.0.1.

Esiste un servizio di sistema che potrebbe esporre qualcosa di simile?


Ho progettato alcune funzioni pronte all'uso per ottenere lo spazio disponibile in unità diverse. Puoi usare questi metodi semplicemente copiando qualcuno di loro nel tuo progetto.

/**
 * @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;
}

In base a this risposta, è stato aggiunto il supporto alla versione Android <18

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

Nuovi metodi sono stati introdotti dalla versione 18 dell'API.

Ho usato qualcosa di simile per la stima della dimensione della cache del disco grande (per la cache del downloader di Picasso OkHttp). Il metodo Helper era così:

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

Prova questo codice

StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());
long bytesAvailable = (long)stat.getBlockSize() *(long)stat.getBlockCount();
long megAvailable = bytesAvailable / 1048576;
System.out.println("Megs :"+megAvailable);

Da li

UPD: getBlockCount () - restituisce la dimensione della scheda SD; getAvailableBlocks () - restituisce il numero di blocchi che sono ancora accessibili ai programmi normali (grazie Joe)


inoltre, se vuoi controllare lo spazio disponibile sulla memoria interna, usa:

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

...


Google ha informazioni su questo nella pagina introduttiva - Vedi Query Free Space. Dicono che è possibile controllare lo spazio disponibile da getFreeSpace() ma dichiarano che questo è inaccurato e che ci si dovrebbe aspettare un po 'meno spazio libero di questo. Dicono:

Se il numero restituito è di qualche MB in più rispetto alla dimensione dei dati che si desidera salvare, o se il file system è pieno al di sotto del 90%, è probabile che sia sicuro procedere. Altrimenti, probabilmente non dovresti scrivere sullo spazio di archiviazione.

Inoltre danno il consiglio che spesso è più utile non controllare lo spazio libero e try catch un errore:

Non è necessario controllare la quantità di spazio disponibile prima di salvare il file. Puoi invece provare a scrivere il file subito, quindi prendere una IOException se si verifica uno. Potrebbe essere necessario farlo se non sai esattamente di quanto spazio hai bisogno. Ad esempio, se si modifica la codifica del file prima di salvarlo convertendo un'immagine PNG in JPEG, non si conoscerà in anticipo la dimensione del file.

Raccomanderei che solo per file di dimensioni molto grandi dovresti controllare in anticipo la memoria disponibile in modo da non perdere tempo a scaricare o creare un file che, ovviamente, è troppo grande da contenere. In entrambi i casi si dovrebbe sempre usare try catch quindi penso che l'unico argomento per verificare in anticipo lo spazio disponibile disponibile sia l'uso non necessario di risorse e il tempo è troppo.







android