web-dev-qa-db-fra.com

Vérifiez si la carte SD est disponible ou non par programme

Mon application ne fonctionne que pour les mobiles dotés d'une carte SD. Je souhaite donc vérifier par programme si la carte SD est disponible ou non et comment trouver l’espace libre sur la carte SD. C'est possible?

Si oui, comment je le fais?

androidsd-card
50
naresh
Boolean isSDPresent = Android.os.Environment.getExternalStorageState().equals(Android.os.Environment.MEDIA_MOUNTED);
Boolean isSDSupportedDevice = Environment.isExternalStorageRemovable();

if(isSDSupportedDevice && isSDPresent)
{
  // yes SD-card is present
}
else
{
 // Sorry
}
126
Paresh Mayani

La réponse acceptée ne fonctionne pas pour moi 

Environment.getExternalStorageState().equals(Android.os.Environment.MEDIA_MOUNTED);

Dans le cas où le périphérique dispose d'un stockage intégré, il renvoie true; Ma solution est-ce pour vérifier le nombre de répertoires de fichiers externes, s'il y en a plusieurs, la carte est sdcard. Cela fonctionne et je l'ai testé pour plusieurs appareils.

public static boolean hasRealRemovableSdCard(Context context) {
    return ContextCompat.getExternalFilesDirs(context, null).length >= 2;
}
12
Jemo Mgebrishvili

Utilisez Environment.getExternalStorageState() comme décrit dans "Utilisation du stockage externe" .

Pour obtenir de l’espace disponible sur le stockage externe, utilisez StatFs :

// do this only *after* you have checked external storage state:
File extdir = Environment.getExternalStorageDirectory();
File stats = new StatFs(extdir.getAbsolutePath());
int availableBytes = stats.getAvailableBlocks() * stats.getBlockSize();
12
Philipp Reichart

J'ai écrit une petite classe pour vérifier l'état de stockage. Peut-être que cela vous sera utile.

import Android.os.Environment;

/**
 * Checks the state of the external storage of the device.
 * 
 * @author kaolick
 */
public class StorageHelper
{
// Storage states
private boolean externalStorageAvailable, externalStorageWriteable;

/**
 * Checks the external storage's state and saves it in member attributes.
 */
private void checkStorage()
{
// Get the external storage's state
String state = Environment.getExternalStorageState();

if (state.equals(Environment.MEDIA_MOUNTED))
{
    // Storage is available and writeable
    externalStorageAvailable = externalStorageWriteable = true;
}
else if (state.equals(Environment.MEDIA_MOUNTED_READ_ONLY))
{
    // Storage is only readable
    externalStorageAvailable = true;
    externalStorageWriteable = false;
}
else
{
    // Storage is neither readable nor writeable
    externalStorageAvailable = externalStorageWriteable = false;
}
}

/**
 * Checks the state of the external storage.
 * 
 * @return True if the external storage is available, false otherwise.
 */
public boolean isExternalStorageAvailable()
{
checkStorage();

return externalStorageAvailable;
}

/**
 * Checks the state of the external storage.
 * 
 * @return True if the external storage is writeable, false otherwise.
 */
public boolean isExternalStorageWriteable()
{
checkStorage();

return externalStorageWriteable;
}

/**
 * Checks the state of the external storage.
 * 
 * @return True if the external storage is available and writeable, false
 *         otherwise.
 */    
public boolean isExternalStorageAvailableAndWriteable()
{
checkStorage();

if (!externalStorageAvailable)
{
    return false;
}
else if (!externalStorageWriteable)
{
    return false;
}
else
{
    return true;
}
}
}
5
kaolick

Vous pouvez vérifier si une carte SD amovible externe est disponible comme ceci

public static boolean externalMemoryAvailable(Activity context) {
    File[] storages = ContextCompat.getExternalFilesDirs(context, null);
    if (storages.length > 1 && storages[0] != null && storages[1] != null)
        return true;
    else
        return false;

}

Cela fonctionne parfaitement comme je l'ai testé.

4
Jaura

Je l'ai modifié de telle sorte que si une carte SD existe, elle y définit le chemin. Sinon, il le place dans le répertoire interne.

Boolean isSDPresent = Android.os.Environment.getExternalStorageState().equals(Android.os.Environment.MEDIA_MOUNTED);
if(isSDPresent)
{
    path = theAct.getExternalCacheDir().getAbsolutePath() + "/GrammarFolder";
}
else
{
    path = theAct.getFilesDir() + "/GrammarFolder";
}
4
ArdaA
 void updateExternalStorageState() {
     String state = Environment.getExternalStorageState();
     if (Environment.MEDIA_MOUNTED.equals(state)) {
        mExternalStorageAvailable = mExternalStorageWriteable = true;
     } else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
        mExternalStorageAvailable = true;
       mExternalStorageWriteable = false;
     } else {
       mExternalStorageAvailable = mExternalStorageWriteable = false;
}
handleExternalStorageState(mExternalStorageAvailable,
        mExternalStorageWriteable);
}
3
Umesh

Cette méthode simple est travaillée pour moi. Testé dans tout type d'appareils.

public boolean externalMemoryAvailable() {
    if (Environment.isExternalStorageRemovable()) {
      //device support sd card. We need to check sd card availability.
      String state = Environment.getExternalStorageState();
      return state.equals(Environment.MEDIA_MOUNTED) || state.equals(
          Environment.MEDIA_MOUNTED_READ_ONLY);
    } else {
      //device not support sd card. 
      return false;
    }
  }
1
Kishan Vaghela

J'ai créé une classe pour vérifier si le dossier de la carte SD est disponible ou non:

public class GetFolderPath {

    static String folderPath;

    public static String getFolderPath(Context context) {
        if (isSdPresent() == true) {
            try {
                File sdPath = new File(Environment.getExternalStorageDirectory().getAbsolutePath()+"/FolderName");
                if(!sdPath.exists()) {
                    sdPath.mkdirs();
                    folderPath = sdPath.getAbsolutePath();
                } else if (sdPath.exists()) {
                    folderPath = sdPath.getAbsolutePath();
                }
            }
            catch (Exception e) {

            }
            folderPath = Environment.getExternalStorageDirectory().getPath()+"/FolderName/";
        }
        else {
            try {
                File cacheDir=new File(context.getCacheDir(),"FolderName/");
                if(!cacheDir.exists()) {
                    cacheDir.mkdirs();
                    folderPath = cacheDir.getAbsolutePath();
                } else if (cacheDir.exists()) {
                    folderPath = cacheDir.getAbsolutePath();
                }
            }
            catch (Exception e){

            }
        }
        return folderPath;
    }

    public static boolean isSdPresent() {
        return Android.os.Environment.getExternalStorageState().equals(Android.os.Environment.MEDIA_MOUNTED);
    }
}
0
UchihaSasuke

Kotlin

fun Context.externalMemoryAvailable(): Boolean {
    val storages = ContextCompat.getExternalFilesDirs(this, null)
    return storages.size > 1 && storages[0] != null && storages[1] != null
}
0
SK Panchal
** i fixed this with help of @Jemo Mgebrishvili answer**

cela fonctionne parfaitement même si la carte SD est présente et à l'état éjecté

 if (ContextCompat.getExternalFilesDirs(this, null).length >= 2) {
                File[] f = ContextCompat.getExternalFilesDirs(this, null);
                for (int i = 0; i < f.length; i++) {
                    File file = f[i];
                    if(file!=null && i ==1)
                    {
                        Log.d(TAG,file.getAbsolutePath()+ "external sd card  available");

                    }

                }
            } else {
                Log.d(TAG, " external sd card not available");

            }
0
rajesh vinew