Comment puis-je obtenir un chemin de carte SD externe pour Android 4.0+?

Samsung Galaxy S3 dispose d’un emplacement pour carte SD supplémentaire, monté sur /mnt/extSdCard .

Ma question est la suivante: comment obtenir ce chemin par quelque chose comme Environment.getExternalStorageDirectory() ? Cela retournera mnt/sdcard , et je ne trouve pas d’API pour une carte SD externe. (Ou stockage USB amovible sur certaines tablettes)

Je vous remercie!

    J’ai une variation sur une solution que j’ai trouvée ici

     public static HashSet getExternalMounts() { final HashSet out = new HashSet(); Ssortingng reg = "(?i).*vold.*(vfat|ntfs|exfat|fat32|ext3|ext4).*rw.*"; Ssortingng s = ""; try { final Process process = new ProcessBuilder().command("mount") .redirectErrorStream(true).start(); process.waitFor(); final InputStream is = process.getInputStream(); final byte[] buffer = new byte[1024]; while (is.read(buffer) != -1) { s = s + new Ssortingng(buffer); } is.close(); } catch (final Exception e) { e.printStackTrace(); } // parse output final Ssortingng[] lines = s.split("\n"); for (Ssortingng line : lines) { if (!line.toLowerCase(Locale.US).contains("asec")) { if (line.matches(reg)) { Ssortingng[] parts = line.split(" "); for (Ssortingng part : parts) { if (part.startsWith("/")) if (!part.toLowerCase(Locale.US).contains("vold")) out.add(part); } } } } return out; } 

    La méthode originale a été testée et travaillée avec

    • Huawei X3 (stock)
    • Galaxy S2 (stock)
    • Galaxy S3 (stock)

    Je ne suis pas sûr de la version Android sur laquelle ils se trouvaient lors de leur test.

    J’ai testé ma version modifiée avec

    • Moto Xoom 4.1.2 (stock)
    • Galaxy Nexus (cyanogenmod 10) utilisant un câble otg
    • HTC Incredible (cyanogenmod 7.2) ceci a renvoyé les deux internes et externes. Ce périphérique est un peu bizarre dans la mesure où son interne devient largement inutilisé, car getExternalStorage () renvoie à la place un chemin vers la carte SD.

    et certains périphériques de stockage uniques qui utilisent une carte SD comme stockage principal

    • HTC G1 (CyanogenMod 6.1)
    • HTC G1 (stock)
    • HTC Vision / G2 (stock)

    Excepté l’Incroyable, tous ces appareils ne renvoient que leur stockage amovible. Il y a probablement quelques vérifications supplémentaires que je devrais faire, mais c’est au moins un peu mieux que n’importe quelle solution que j’ai trouvée jusqu’à présent.

    J’ai trouvé un moyen plus fiable d’obtenir des chemins vers toutes les cartes SD-CARD dans le système. Cela fonctionne sur toutes les versions Android et renvoie des chemins vers tous les stockages (y compris émulé).

    Fonctionne correctement sur tous mes appareils.

    PS: Basé sur le code source de la classe Environment.

     private static final Pattern DIR_SEPORATOR = Pattern.comstack("/"); /** * Raturns all available SD-Cards in the system (include emulated) * * Warning: Hack! Based on Android source code of version 4.3 (API 18) * Because there is no standart way to get it. * TODO: Test on future Android versions 4.4+ * * @return paths to all available SD-Cards in the system (include emulated) */ public static Ssortingng[] getStorageDirectories() { // Final set of paths final Set rv = new HashSet(); // Primary physical SD-CARD (not emulated) final Ssortingng rawExternalStorage = System.getenv("EXTERNAL_STORAGE"); // All Secondary SD-CARDs (all exclude primary) separated by ":" final Ssortingng rawSecondaryStoragesStr = System.getenv("SECONDARY_STORAGE"); // Primary emulated SD-CARD final Ssortingng rawEmulatedStorageTarget = System.getenv("EMULATED_STORAGE_TARGET"); if(TextUtils.isEmpty(rawEmulatedStorageTarget)) { // Device has physical external storage; use plain paths. if(TextUtils.isEmpty(rawExternalStorage)) { // EXTERNAL_STORAGE undefined; falling back to default. rv.add("/storage/sdcard0"); } else { rv.add(rawExternalStorage); } } else { // Device has emulated storage; external storage paths should have // userId burned into them. final Ssortingng rawUserId; if(Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) { rawUserId = ""; } else { final String path = Environment.getExternalStorageDirectory().getAbsolutePath(); final String[] folders = DIR_SEPORATOR.split(path); final String lastFolder = folders[folders.length - 1]; boolean isDigit = false; try { Integer.valueOf(lastFolder); isDigit = true; } catch(NumberFormatException ignored) { } rawUserId = isDigit ? lastFolder : ""; } // /storage/emulated/0[1,2,...] if(TextUtils.isEmpty(rawUserId)) { rv.add(rawEmulatedStorageTarget); } else { rv.add(rawEmulatedStorageTarget + File.separator + rawUserId); } } // Add all secondary storages if(!TextUtils.isEmpty(rawSecondaryStoragesStr)) { // All Secondary SD-CARDs splited into array final String[] rawSecondaryStorages = rawSecondaryStoragesStr.split(File.pathSeparator); Collections.addAll(rv, rawSecondaryStorages); } return rv.toArray(new String[rv.size()]); } 

    Je suppose que pour utiliser la carte SD externe, vous devez utiliser ceci:

     new File("/mnt/external_sd/") 

    OU

     new File("/mnt/extSdCard/") 

    dans ton cas…

    en remplacement de Environment.getExternalStorageDirectory()

    Travaille pour moi. Vous devriez vérifier ce qui se trouve dans le répertoire mnt et travailler à partir de là ..


    Vous devez utiliser un type de méthode de sélection pour choisir la carte SD à utiliser:

     File storageDir = new File("/mnt/"); if(storageDir.isDirectory()){ Ssortingng[] dirList = storageDir.list(); //TODO some type of selecton method? } 

    Pour récupérer tous les stockages externes (qu’il s’agisse de cartes SD ou de stockages internes non amovibles ), vous pouvez utiliser le code suivant:

     final Ssortingng state = Environment.getExternalStorageState(); if ( Environment.MEDIA_MOUNTED.equals(state) || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state) ) { // we can read the External Storage... //Resortingeve the primary External Storage: final File primaryExternalStorage = Environment.getExternalStorageDirectory(); //Resortingeve the External Storages root directory: final Ssortingng externalStorageRootDir; if ( (externalStorageRootDir = primaryExternalStorage.getParent()) == null ) { // no parent... Log.d(TAG, "External Storage: " + primaryExternalStorage + "\n"); } else { final File externalStorageRoot = new File( externalStorageRootDir ); final File[] files = externalStorageRoot.listFiles(); for ( final File file : files ) { if ( file.isDirectory() && file.canRead() && (file.listFiles().length > 0) ) { // it is a real directory (not a USB drive)... Log.d(TAG, "External Storage: " + file.getAbsolutePath() + "\n"); } } } } 

    Vous pouvez également utiliser System.getenv (“EXTERNAL_STORAGE”) pour récupérer le répertoire de stockage externe principal (par exemple “/ storage / sdcard0” ) et System.getenv (“SECONDARY_STORAGE”) pour récupérer la liste de tous les répertoires secondaires (par exemple ” / storage / extSdCard: / storage / UsbDriveA: / storage / UsbDriveB “ ). Rappelez-vous que, même dans ce cas, vous pourriez vouloir filtrer la liste des répertoires secondaires afin d’exclure les lecteurs USB.

    Dans tous les cas, veuillez noter que l’utilisation de chemins codés en dur est toujours une mauvaise approche (en particulier lorsque chaque fabricant peut le modifier avec plaisir).

    J’utilisais la solution de Dmisortingy Lozenko jusqu’à ce que je vérifie sur un Asus Zenfone2 , Marshmallow 6.0.1 et que la solution ne fonctionne pas. La solution a échoué lors de l’obtention d’ EMULATED_STORAGE_TARGET , spécifiquement pour le chemin microSD, à savoir: / storage / F99C-10F4 / . J’ai édité le code pour obtenir les chemins racine émulés directement à partir des chemins d’application émulés avec context.getExternalFilesDirs(null); et append d’autres chemins physiques spécifiques au modèle de téléphone .

    Pour nous faciliter la vie, j’ai créé une bibliothèque ici . Vous pouvez l’utiliser via gradle, maven, sbt et leiningen build system.

    Si vous aimez l’ancienne méthode, vous pouvez également copier coller le fichier directement à partir d’ ici , mais vous ne saurez pas s’il y aura une mise à jour dans le futur sans la vérifier manuellement.

    Si vous avez des questions ou des suggestions, faites-le moi savoir.

    Bonnes nouvelles! Dans KitKat, il existe maintenant une API publique pour interagir avec ces périphériques de stockage partagés secondaires.

    Les nouvelles Context.getExternalFilesDirs() et Context.getExternalCacheDirs() peuvent renvoyer plusieurs chemins, y compris des périphériques principaux et secondaires. Vous pouvez ensuite les parcourir et vérifier Environment.getStorageState() et File.getFreeSpace() pour déterminer le meilleur emplacement pour stocker vos fichiers. Ces méthodes sont également disponibles sur ContextCompat dans la bibliothèque support-v4.

    Notez également que si vous souhaitez uniquement utiliser les répertoires renvoyés par Context , vous n’avez plus besoin des permissions READ_ ou WRITE_EXTERNAL_STORAGE . À l’avenir, vous aurez toujours un access en lecture / écriture à ces répertoires, sans aucune autorisation supplémentaire requirejse.

    Les applications peuvent également continuer à travailler sur des appareils plus anciens en fin de vie, grâce à leur demande d’autorisation comme ceci:

      

    J’ai fait ce qui suit pour accéder à toutes les cartes SD externes.

    Avec:

     File primaryExtSd=Environment.getExternalStorageDirectory(); 

    vous obtenez le chemin vers la SD externe primaire Puis avec:

     File parentDir=new File(primaryExtSd.getParent()); 

    vous obtenez le répertoire parent du stockage externe principal, et il est également le parent de tous les fichiers SD externes. Maintenant, vous pouvez lister tout le stockage et sélectionner celui que vous voulez.

    J’espère que c’est utile.

    Voici comment obtenir la liste des chemins de carte SD (à l’exclusion du stockage externe principal):

      /** * returns a list of all available sd cards paths, or null if not found. * * @param includePrimaryExternalStorage set to true if you wish to also include the path of the primary external storage */ @TargetApi(Build.VERSION_CODES.HONEYCOMB) public static List getSdCardPaths(final Context context,final boolean includePrimaryExternalStorage) { final File[] externalCacheDirs=ContextCompat.getExternalCacheDirs(context); if(externalCacheDirs==null||externalCacheDirs.length==0) return null; if(externalCacheDirs.length==1) { if(externalCacheDirs[0]==null) return null; final Ssortingng storageState=EnvironmentCompat.getStorageState(externalCacheDirs[0]); if(!Environment.MEDIA_MOUNTED.equals(storageState)) return null; if(!includePrimaryExternalStorage&&VERSION.SDK_INT>=VERSION_CODES.HONEYCOMB&&Environment.isExternalStorageEmulated()) return null; } final List result=new ArrayList<>(); if(includePrimaryExternalStorage||externalCacheDirs.length==1) result.add(getRootOfInnerSdCardFolder(externalCacheDirs[0])); for(int i=1;i 

    Merci pour les indices fournis par vous, en particulier @SmartLemon, j’ai la solution. Si quelqu’un d’autre en a besoin, je mets ma solution finale ici (pour trouver la première carte SD externe répertoriée):

     public File getExternalSDCardDirectory() { File innerDir = Environment.getExternalStorageDirectory(); File rootDir = innerDir.getParentFile(); File firstExtSdCard = innerDir ; File[] files = rootDir.listFiles(); for (File file : files) { if (file.compareTo(innerDir) != 0) { firstExtSdCard = file; break; } } //Log.i("2", firstExtSdCard.getAbsolutePath().toSsortingng()); return firstExtSdCard; } 

    S’il n’y a pas de carte SD externe, elle renvoie le stockage embarqué. Je vais l’utiliser si la carte SD n’existe pas, vous devrez peut-être la changer.

    se référer à mon code, espère utile pour vous:

      Runtime runtime = Runtime.getRuntime(); Process proc = runtime.exec("mount"); InputStream is = proc.getInputStream(); InputStreamReader isr = new InputStreamReader(is); Ssortingng line; Ssortingng mount = new Ssortingng(); BufferedReader br = new BufferedReader(isr); while ((line = br.readLine()) != null) { if (line.contains("secure")) continue; if (line.contains("asec")) continue; if (line.contains("fat")) {//TF card Ssortingng columns[] = line.split(" "); if (columns != null && columns.length > 1) { mount = mount.concat("*" + columns[1] + "\n"); } } else if (line.contains("fuse")) {//internal storage Ssortingng columns[] = line.split(" "); if (columns != null && columns.length > 1) { mount = mount.concat(columns[1] + "\n"); } } } txtView.setText(mount); 

    En fait, dans certains appareils, le nom par défaut de la carte sdcard externe est extSdCard et pour d’autres, sdcard1 .

    Cet extrait de code permet de trouver le chemin exact et de récupérer le chemin du périphérique externe.

     Ssortingng sdpath,sd1path,usbdiskpath,sd0path; if(new File("/storage/extSdCard/").exists()) { sdpath="/storage/extSdCard/"; Log.i("Sd Cardext Path",sdpath); } if(new File("/storage/sdcard1/").exists()) { sd1path="/storage/sdcard1/"; Log.i("Sd Card1 Path",sd1path); } if(new File("/storage/usbcard1/").exists()) { usbdiskpath="/storage/usbcard1/"; Log.i("USB Path",usbdiskpath); } if(new File("/storage/sdcard0/").exists()) { sd0path="/storage/sdcard0/"; Log.i("Sd Card0 Path",sd0path); } 

    Oui. Un fabricant différent utilise un nom de carte SD différent, comme dans Samsung Tab 3, son extsd, et d’autres appareils samsung utilisent une carte SD comme ce fabricant différent utilise des noms différents.

    J’ai eu les mêmes exigences que vous. J’ai donc créé pour vous un exemple à partir de mon projet goto cet exemple de sélecteur d’Android Directory qui utilise la bibliothèque androi-dirchooser. Cet exemple détecte la carte SD et répertorie tous les sous-dossiers et détecte également si le périphérique a plus d’une carte SD.

    Une partie du code ressemble à ceci Pour un exemple complet allez dans le lien Sélecteur de répertoire Android

     /** * Returns the path to internal storage ex:- /storage/emulated/0 * * @return */ private Ssortingng getInternalDirectoryPath() { return Environment.getExternalStorageDirectory().getAbsolutePath(); } /** * Returns the SDcard storage path for samsung ex:- /storage/extSdCard * * @return */ private Ssortingng getSDcardDirectoryPath() { return System.getenv("SECONDARY_STORAGE"); } mSdcardLayout.setOnClickListener(new OnClickListener() { @Override public void onClick(View view) { Ssortingng sdCardPath; /*** * Null check because user may click on already selected buton before selecting the folder * And mSelectedDir may contain some wrong path like when user confirm dialog and swith back again */ if (mSelectedDir != null && !mSelectedDir.getAbsolutePath().contains(System.getenv("SECONDARY_STORAGE"))) { mCurrentInternalPath = mSelectedDir.getAbsolutePath(); } else { mCurrentInternalPath = getInternalDirectoryPath(); } if (mCurrentSDcardPath != null) { sdCardPath = mCurrentSDcardPath; } else { sdCardPath = getSDcardDirectoryPath(); } //When there is only one SDcard if (sdCardPath != null) { if (!sdCardPath.contains(":")) { updateButtonColor(STORAGE_EXTERNAL); File dir = new File(sdCardPath); changeDirectory(dir); } else if (sdCardPath.contains(":")) { //Multiple Sdcards show root folder and remove the Internal storage from that. updateButtonColor(STORAGE_EXTERNAL); File dir = new File("/storage"); changeDirectory(dir); } } else { //In some unknown scenario at least we can list the root folder updateButtonColor(STORAGE_EXTERNAL); File dir = new File("/storage"); changeDirectory(dir); } } }); 

    Cette solution (assemblée à partir d’autres réponses à cette question) gère le fait (comme mentionné par @ono) que System.getenv("SECONDARY_STORAGE") est inutile avec Marshmallow.

    Testé et travaillant sur:

    • Samsung Galaxy Tab 2 (Android 4.1.1 – Stock)
    • Samsung Galaxy Note 8.0 (Android 4.2.2 – Stock)
    • Samsung Galaxy S4 (Android 4.4 – Stock)
    • Samsung Galaxy S4 (Android 5.1.1 – CyanogenMod)
    • Samsung Galaxy Tab A (Android 6.0.1 – Stock)

       /** * Returns all available external SD-Card roots in the system. * * @return paths to all available external SD-Card roots in the system. */ public static Ssortingng[] getStorageDirectories() { Ssortingng [] storageDirectories; Ssortingng rawSecondaryStoragesStr = System.getenv("SECONDARY_STORAGE"); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { List results = new ArrayList(); File[] externalDirs = applicationContext.getExternalFilesDirs(null); for (File file : externalDirs) { Ssortingng path = file.getPath().split("/Android")[0]; if((Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && Environment.isExternalStorageRemovable(file)) || rawSecondaryStoragesStr != null && rawSecondaryStoragesStr.contains(path)){ results.add(path); } } storageDirectories = results.toArray(new Ssortingng[0]); }else{ final Set rv = new HashSet(); if (!TextUtils.isEmpty(rawSecondaryStoragesStr)) { final Ssortingng[] rawSecondaryStorages = rawSecondaryStoragesStr.split(File.pathSeparator); Collections.addAll(rv, rawSecondaryStorages); } storageDirectories = rv.toArray(new Ssortingng[rv.size()]); } return storageDirectories; } 

    Sur certains appareils (par exemple samsung galaxy sII), la carte mémoire interne mabe doit être en vfat. Dans ce cas, utilisez le dernier code de référence, nous obtenons la carte mémoire interne du chemin (/ mnt / sdcad) mais aucune carte externe. Code référence ci-dessous résoudre ce problème.

     static Ssortingng getExternalStorage(){ Ssortingng exts = Environment.getExternalStorageDirectory().getPath(); try { FileReader fr = new FileReader(new File("/proc/mounts")); BufferedReader br = new BufferedReader(fr); Ssortingng sdCard=null; Ssortingng line; while((line = br.readLine())!=null){ if(line.contains("secure") || line.contains("asec")) continue; if(line.contains("fat")){ Ssortingng[] pars = line.split("\\s"); if(pars.length<2) continue; if(pars[1].equals(exts)) continue; sdCard =pars[1]; break; } } fr.close(); br.close(); return sdCard; } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; } 
      File[] files = null; File file = new File("/storage");// /storage/emulated if (file.exists()) { files = file.listFiles(); } if (null != files) for (int j = 0; j < files.length; j++) { Log.e(TAG, "" + files[j]); Log.e(TAG, "//--//--// " + files[j].exists()); if (files[j].toString().replaceAll("_", "") .toLowerCase().contains("extsdcard")) { external_path = files[j].toString(); break; } else if (files[j].toString().replaceAll("_", "") .toLowerCase() .contains("sdcard".concat(Integer.toString(j)))) { // external_path = files[j].toString(); } Log.e(TAG, "--///--///-- " + external_path); } 

    Je suis sûr que ce code va sûrement résoudre vos problèmes … Cela fonctionne très bien pour moi … \

     try { File mountFile = new File("/proc/mounts"); usbFoundCount=0; sdcardFoundCount=0; if(mountFile.exists()) { Scanner usbscanner = new Scanner(mountFile); while (usbscanner.hasNext()) { Ssortingng line = usbscanner.nextLine(); if (line.startsWith("/dev/fuse /storage/usbcard1")) { usbFoundCount=1; Log.i("-----USB--------","USB Connected and properly mounted---/dev/fuse /storage/usbcard1" ); } } } if(mountFile.exists()){ Scanner sdcardscanner = new Scanner(mountFile); while (sdcardscanner.hasNext()) { Ssortingng line = sdcardscanner.nextLine(); if (line.startsWith("/dev/fuse /storage/sdcard1")) { sdcardFoundCount=1; Log.i("-----USB--------","USB Connected and properly mounted---/dev/fuse /storage/sdcard1" ); } } } if(usbFoundCount==1) { Toast.makeText(context,"USB Connected and properly mounted", 7000).show(); Log.i("-----USB--------","USB Connected and properly mounted" ); } else { Toast.makeText(context,"USB not found!!!!", 7000).show(); Log.i("-----USB--------","USB not found!!!!" ); } if(sdcardFoundCount==1) { Toast.makeText(context,"SDCard Connected and properly mounted", 7000).show(); Log.i("-----SDCard--------","SDCard Connected and properly mounted" ); } else { Toast.makeText(context,"SDCard not found!!!!", 7000).show(); Log.i("-----SDCard--------","SDCard not found!!!!" ); } }catch (Exception e) { e.printStackTrace(); } 

    ce n’est pas vrai. / mnt / sdcard / external_sd peut exister même si la carte SD n’est pas montée. votre application se bloque lorsque vous essayez d’écrire dans / mnt / sdcard / external_sd quand il n’est pas monté.

    vous devez vérifier si la carte SD est montée en premier en utilisant:

     boolean isSDPresent = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED); 
      Ssortingng path = Environment.getExternalStorageDirectory() + File.separator + Environment.DIRECTORY_PICTURES; File dir = new File(path); 

    Vous pouvez utiliser quelque chose comme – Context.getExternalCacheDirs () ou Context.getExternalFilesDirs () ou Context.getObbDirs (). Ils fournissent des répertoires spécifiques aux applications sur tous les périphériques de stockage externes où l’application peut stocker ses fichiers.

    Donc quelque chose comme ceci – Context.getExternalCacheDirs () [i] .getParentFile (). GetParentFile (). GetParentFile (). GetParent () peut vous procurer le chemin racine des périphériques de stockage externes.

    Je sais que ces commandes ont un but différent, mais d’autres réponses ne fonctionnaient pas pour moi.

    Ce lien m’a donné de bonnes indications – https://possiblemobile.com/2014/03/android-external-storage/

    System.getenv("SECONDARY_STORAGE") renvoie null pour Marshmallow. Ceci est une autre façon de trouver tous les répertoires externes. Vous pouvez vérifier si elle est amovible, ce qui détermine si interne / externe

     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { File[] externalCacheDirs = context.getExternalCacheDirs(); for (File file : externalCacheDirs) { if (Environment.isExternalStorageRemovable(file)) { // It's a removable storage } } } 

    J’ai essayé les solutions fournies par Dmisortingy Lozenko et Gnathonic sur mon Samsung Galaxy Tab S2 (modèle: T819Y) mais aucune ne m’a aidé à récupérer le chemin vers un répertoire de carte SD externe. mount exécution de la commande de mount contenait le chemin d’access requirejs vers le répertoire de la carte SD externe (par exemple / Storage / A5F9-15F4), mais elle ne correspondait pas à l’expression régulière et n’a donc pas été renvoyée. Je n’obtiens pas le mécanisme de désignation des répertoires suivi par Samsung. Pourquoi ils s’écartent des normes (c.-à-d. Extsdcard) et proposent quelque chose de vraiment louche comme dans mon cas (ie / Storage / A5F9-15F4) . Y a-t-il quelque chose qui me manque? Quoi qu’il en soit, suite à des changements dans les expressions régulières de la solution de Gnathonic, cela m’a permis d’obtenir un répertoire sdcard valide:

     final HashSet out = new HashSet(); Ssortingng reg = "(?i).*(vold|media_rw).*(sdcard|vfat|ntfs|exfat|fat32|ext3|ext4).*rw.*"; Ssortingng s = ""; try { final Process process = new ProcessBuilder().command("mount") .redirectErrorStream(true).start(); process.waitFor(); final InputStream is = process.getInputStream(); final byte[] buffer = new byte[1024]; while (is.read(buffer) != -1) { s = s + new Ssortingng(buffer); } is.close(); } catch (final Exception e) { e.printStackTrace(); } // parse output final Ssortingng[] lines = s.split("\n"); for (Ssortingng line : lines) { if (!line.toLowerCase(Locale.US).contains("asec")) { if (line.matches(reg)) { Ssortingng[] parts = line.split(" "); for (Ssortingng part : parts) { if (part.startsWith("/")) if (!part.toLowerCase(Locale.US).contains("vold")) out.add(part); } } } } return out; 

    Je ne suis pas sûr qu’il s’agisse d’une solution valide et si elle donnera des résultats pour d’autres tablettes Samsung, mais elle a résolu mon problème pour le moment. Voici une autre méthode pour récupérer un chemin de carte SD amovible dans Android (v6.0). J’ai testé la méthode avec la guimauve Android et ça marche. L’approche utilisée est très basique et fonctionnera sûrement pour d’autres versions également, mais les tests sont obligatoires. Un aperçu sera utile:

     public static Ssortingng getSDCardDirPathForAndroidMarshmallow() { File rootDir = null; try { // Getting external storage directory file File innerDir = Environment.getExternalStorageDirectory(); // Temporarily saving resortingeved external storage directory as root // directory rootDir = innerDir; // Splitting path for external storage directory to get its root // directory Ssortingng externalStorageDirPath = innerDir.getAbsolutePath(); if (externalStorageDirPath != null && externalStorageDirPath.length() > 1 && externalStorageDirPath.startsWith("/")) { externalStorageDirPath = externalStorageDirPath.subssortingng(1, externalStorageDirPath.length()); } if (externalStorageDirPath != null && externalStorageDirPath.endsWith("/")) { externalStorageDirPath = externalStorageDirPath.subssortingng(0, externalStorageDirPath.length() - 1); } Ssortingng[] pathElements = externalStorageDirPath.split("/"); for (int i = 0; i < pathElements.length - 1; i++) { rootDir = rootDir.getParentFile(); } File[] files = rootDir.listFiles(); for (File file : files) { if (file.exists() && file.compareTo(innerDir) != 0) { // Try-catch is implemented to prevent from any IO exception try { if (Environment.isExternalStorageRemovable(file)) { return file.getAbsolutePath(); } } catch (Exception e) { e.printStackTrace(); } } } } catch (Exception ex) { ex.printStackTrace(); } return null; } 

    Kindly share if you have any other approach to handle this issue. Merci

     Ssortingng secStore = System.getenv("SECONDARY_STORAGE"); File externalsdpath = new File(secStore); 

    This will get the path of external sd secondary storage.

     //manifest file outside the application tag //please give permission write this // File file = new File("/mnt"); Ssortingng[] fileNameList = file.list(); //file names list inside the mnr folder Ssortingng all_names = ""; //for the log information Ssortingng foundedFullNameOfExtCard = ""; // full name of ext card will come here boolean isExtCardFounded = false; for (Ssortingng name : fileNameList) { if (!isExtCardFounded) { isExtCardFounded = name.contains("ext"); foundedFullNameOfExtCard = name; } all_names += name + "\n"; // for log } Log.d("dialog", all_names + foundedFullNameOfExtCard); 

    To access files in my SD card , on my HTC One X (Android), I use this path:

     file:///storage/sdcard0/folder/filename.jpg 

    Note the sortingpple “/” !

    On Galaxy S3 Android 4.3 the path I use is ./storage/extSdCard/Card/ and it does the job. J’espère que cela aide,

    Les étapes suivantes ont fonctionné pour moi. You just need to write this lines:

     Ssortingng sdf = new Ssortingng(Environment.getExternalStorageDirectory().getName()); Ssortingng sddir = new Ssortingng(Environment.getExternalStorageDirectory().getPath().replace(sdf,"")); 

    The first line will give the name of sd directory, and you just need to use it in the replace method for the second ssortingng. The second ssortingng will contain the path for the internal and removable sd(/storage/ in my case) . I just needed this path for my app but you can go further if you need it.