web-dev-qa-db-fra.com

Chemin du fichier SDCard externe pour Android

Est-il vrai que le chemin d'accès aux cartes SD externes sur les appareils Android est toujours "/ storage/extSdCard" ? Si non, combien y a-t-il de variations?

J'en ai besoin pour que mon application teste la disponibilité de external SDCard.

J'utilise Titanium, il a une méthodeTitanium.Filesystem.isExternalStoragePresent () Mais il retourne toujours vrai même si la carte SD externe n'est pas montée 

Je pense qu'il détecte SDCard au stockage local retourne donc vrai. Mais ce que je veux vraiment, c’est de détecter si une carte SD physique est montée ou non.

Puis-je le faire en détectant l’existence du fichier "/ storage/extSdCard" alone?

Merci.

androidtitaniumexternalsd-cardandroid-sdcard
11
Bowie

Est-il vrai que le chemin d'accès aux cartes SD externes sur les appareils Android est toujours "/ storage/extSdCard"? Si non, combien y a-t-il de variations?

Malheureusement, le chemin d'accès au stockage externe n'est pas toujours le même selon le fabricant. Utiliser Environment.getExternalStorageDirectory() vous renverra le chemin normal pour la carte SD qui est mnt/sdcard/. Mais pour les appareils Samsung par exemple, le chemin de la carte SD est soit sous mnt/extSdCard/, soit sous mnt/external_sd/.

Donc, une façon de procéder serait de vérifier l'existence d'un répertoire externe en fonction du chemin utilisé par chaque fabricant. Avec quelque chose comme ça:

mExternalDirectory = Environment.getExternalStorageDirectory()
            .getAbsolutePath();
    if (Android.os.Build.DEVICE.contains("samsung")
            || Android.os.Build.MANUFACTURER.contains("samsung")) {
        File f = new File(Environment.getExternalStorageDirectory()
                .getParent() + "/extSdCard" + "/myDirectory");
        if (f.exists() && f.isDirectory()) {
            mExternalDirectory = Environment.getExternalStorageDirectory()
                    .getParent() + "/extSdCard";
        } else {
            f = new File(Environment.getExternalStorageDirectory()
                    .getAbsolutePath() + "/external_sd" + "/myDirectory");  
            if (f.exists() && f.isDirectory()) {
                mExternalDirectory = Environment
                        .getExternalStorageDirectory().getAbsolutePath()
                        + "/external_sd";
            }
        }
    }

Mais ce que je veux vraiment, c’est de détecter si une carte SD physique est montée ou non.

Je n'ai pas encore essayé le code, mais l'approche de Dmitriy Lozenko dans cette réponse est beaucoup plus intéressante. Sa méthode renvoie le chemin de toutes les cartes SD montées sur le système, quel que soit le fabricant.

5
Digoun

J'espère que ça vous sera utile :)

import Android.os.Environment;
import Java.io.File;
import Java.util.ArrayList;
import Java.util.HashMap;
import Java.util.List;
import Java.util.Map;
import Java.util.Scanner;


public class MemoryStorage {

    private MemoryStorage() {}

    public static final String SD_CARD = "sdCard";
    public static final String EXTERNAL_SD_CARD = "externalSdCard";

    /**
     * @return True if the external storage is available. False otherwise.
     */
    public static boolean isAvailable() {
        String state = Environment.getExternalStorageState();
        if (Environment.MEDIA_MOUNTED.equals(state) || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
            return true;
        }
        return false;
    }

    public static String getSdCardPath() {
        return Environment.getExternalStorageDirectory().getPath() + "/";
    }

    /**
     * @return True if the external storage is writable. False otherwise.
     */
    public static boolean isWritable() {
        String state = Environment.getExternalStorageState();
        if (Environment.MEDIA_MOUNTED.equals(state)) {
            return true;
        }
        return false;

    }

    /**
     * @return A map of all storage locations available
     */
    public static Map<String, File> getAllStorageLocations() {
        Map<String, File> map = new HashMap<String, File>(10);

        List<String> mMounts = new ArrayList<String>(10);
        List<String> mVold = new ArrayList<String>(10);
        mMounts.add("/mnt/sdcard");
        mVold.add("/mnt/sdcard");

        try {
            File mountFile = new File("/proc/mounts");
            if (mountFile.exists()) {
                Scanner scanner = new Scanner(mountFile);
                while (scanner.hasNext()) {
                    String line = scanner.nextLine();
                    if (line.startsWith("/dev/block/vold/")) {
                        String[] lineElements = line.split(" ");
                        String element = lineElements[1];

                        // don't add the default mount path
                        // it's already in the list.
                        if (!element.equals("/mnt/sdcard"))
                            mMounts.add(element);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            File voldFile = new File("/system/etc/vold.fstab");
            if (voldFile.exists()) {
                Scanner scanner = new Scanner(voldFile);
                while (scanner.hasNext()) {
                    String line = scanner.nextLine();
                    if (line.startsWith("dev_mount")) {
                        String[] lineElements = line.split(" ");
                        String element = lineElements[2];

                        if (element.contains(":"))
                            element = element.substring(0, element.indexOf(":"));
                        if (!element.equals("/mnt/sdcard"))
                            mVold.add(element);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


        for (int i = 0; i < mMounts.size(); i++) {
            String mount = mMounts.get(i);
            if (!mVold.contains(mount))
                mMounts.remove(i--);
        }
        mVold.clear();

        List<String> mountHash = new ArrayList<String>(10);

        for (String mount : mMounts) {
            File root = new File(mount);
            if (root.exists() && root.isDirectory() && root.canWrite()) {
                File[] list = root.listFiles();
                String hash = "[";
                if (list != null) {
                    for (File f : list) {
                        hash += f.getName().hashCode() + ":" + f.length() + ", ";
                    }
                }
                hash += "]";
                if (!mountHash.contains(hash)) {
                    String key = SD_CARD + "_" + map.size();
                    if (map.size() == 0) {
                        key = SD_CARD;
                    } else if (map.size() == 1) {
                        key = EXTERNAL_SD_CARD;
                    }
                    mountHash.add(hash);
                    map.put(key, root);
                }
            }
        }

        mMounts.clear();

        if (map.isEmpty()) {
            map.put(SD_CARD, Environment.getExternalStorageDirectory());
        }
        return map;
    }
}
5
Alex Evtushik

Voici comment j'ai finalement obtenu le chemin de la carte sd en utilisant:

public String getExternalStoragePath() {

        String internalPath = Environment.getExternalStorageDirectory().getAbsolutePath();
        String[] paths = internalPath.split("/");
        String parentPath = "/";
        for (String s : paths) {
            if (s.trim().length() > 0) {
                parentPath = parentPath.concat(s);
                break;
            }
        }
        File parent = new File(parentPath);
        if (parent.exists()) {
            File[] files = parent.listFiles();
            for (File file : files) {
                String filePath = file.getAbsolutePath();
                Log.d(TAG, filePath);
                if (filePath.equals(internalPath)) {
                    continue;
                } else if (filePath.toLowerCase().contains("sdcard")) {
                    return filePath;
                } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Lollipop) {
                    try {
                        if (Environment.isExternalStorageRemovable(file)) {
                            return filePath;
                        }
                    } catch (RuntimeException e) {
                        Log.e(TAG, "RuntimeException: " + e);
                    }
                }
            }

        }
        return null;
    }
2
Honey Agarwal

Je viens de comprendre quelque chose. Au moins pour mon émulateur Android, j'avais le chemin de la carte SD comme '/ storage/???? - ???? 'où chaque? est une lettre majuscule ou un chiffre.

Ainsi, si/storage/répertoire a un répertoire qui est lisible et qui n'est pas le répertoire de stockage interne, il doit s'agir de la carte SD.

Mon code a fonctionné sur mon émulateur Android!

String removableStoragePath;
    File fileList[] = new File("/storage/").listFiles();
    for (File file : fileList)
  {     if(!file.getAbsolutePath().equalsIgnoreCase(Environment.getExternalStorageDirectory().getAbsolutePath()) && file.isDirectory() && file.canRead())
        removableStoragePath = file.getAbsolutePath();  }
    //If there is an SD Card, removableStoragePath will have it's path. If there isn't it will be an empty string.

S'il existe une carte SD, amovibleStoragePath aura son chemin. S'il n'y en a pas, ce sera une chaîne vide.

1
Paresh Kalinani

J'ai la solution à ce sujet après 4 jours. Veuillez noter les points suivants lors du chemin d'accès à la classe File dans Android (Java):

  1. Utiliser le chemin pour le stockage interne String path="/storage/sdcard0/myfile.txt";
  2. utiliser le chemin pour le stockage externe path="/storage/sdcard1/myfile.txt";
  3. mentionnez les autorisations dans le fichier manifeste.

<uses-permission Android:name="Android.permission.WRITE_EXTERNAL_STORAGE" />

<uses-permission Android:name="Android.permission.READ_EXTERNAL_STORAGE" />

  1. Vérifiez d'abord la longueur du fichier pour confirmation.
  2. Vérifiez les chemins dans ES File Explorer concernant sdcard0 & sdcard1 est Même ou sinon ...

par exemple.:

File file = new File(path);
long = file.length();//in Bytes
1
Mahadev Mane

manière la plus simple, installez ce navigateur de fichiers gratuit et accédez à votre carte SD. Vous lirez le chemin en haut . Dans mon cas, le chemin était: storage/extsd/extsd01 / https://play.google.com/store/apps/details?id=com.smartwho. SmartFileManager

1
PippoApps.com