Join FlipAndroid.COM Telegram Group: https://t.me/joinchat/F_aqThGkhwcLzmI49vKAiw


Ruta de archivo SDCard externa para Android

¿Es cierto que la ruta del archivo a SDCard externa en dispositivos Android es siempre "/ storage / extSdCard" ? Si no, ¿cuántas variaciones hay?

Lo necesito para que mi aplicación pruebe la disponibilidad de la tarjeta SD externa .

  • Usando HttpClient y HttpPost en Android con parámetros post
  • Desplazamiento hacia abajo activa la actualización en lugar de revelar la barra de herramientas
  • ¿Por qué no Service.onStop método?
  • Opciones gratuitas de Corona SDK
  • Cómo establecer diferentes columnas para filas en android gridview
  • ¿Es posible iniciar un DialogFragment desde una preferencia en una preferenciaActivity?
  • Estoy usando Titanium, tiene un método Titanium.Filesystem.isExternalStoragePresent () pero siempre devuelve true incluso SDCard externo no está montado.

    Creo que detectar SDCard en el almacenamiento local, por lo tanto, devolver verdad. Pero lo que realmente quiero es detectar si SDCard físico está montado o no.

    ¿Puedo hacer esto detectando la existencia del archivo "/ storage / extSdCard" solo?

    Gracias.

  • Cambiar la animación del fragmento ya en la pila
  • ¿Cómo puedo configurar un tema diferente para el menú desplegable de un Spinner?
  • Error al utilizar elementos de la biblioteca de soporte de diseño de Android
  • Firewall de Android con VpnService
  • Personalización de las pestañas de ActionBar en Android 4
  • Anular la disposición xml del marco de android
  • 5 Solutions collect form web for “Ruta de archivo SDCard externa para Android”

    Espero que sea útil para usted 🙂

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

    ¿Es cierto que la ruta del archivo a SDCard externa en dispositivos Android es siempre "/ storage / extSdCard"? Si no, ¿cuántas variaciones hay?

    Lamentablemente, el camino hacia el almacenamiento externo no es siempre el mismo según el fabricante. El uso de Environment.getExternalStorageDirectory() le devolverá la ruta normal para la tarjeta SD que es mnt/sdcard/ . Pero para dispositivos Samsung, por ejemplo, la ruta de la tarjeta SD está en mnt/extSdCard/ o en mnt/external_sd/ .

    Así que una manera de proceder sería comprobar la existencia de directorio externo de acuerdo con la ruta utilizada por cada fabricante. Con algo como esto:

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

    Pero lo que realmente quiero es detectar si SDCard físico está montado o no.

    No he probado el código todavía, pero el enfoque de Dmitriy Lozenko en esta respuesta es mucho más interesante. Su método devuelve la ruta de todas las tarjetas SD montadas en sytem independientemente del fabricante .

    Esto es cómo finalmente conseguí la trayectoria del sdcard usando:

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

    Tengo la solución en esto después de 4 días, observa por favor los puntos siguientes mientras que da la trayectoria a la clase del archivo en androide (Java):

    1. Utilice ruta de acceso para el almacenamiento interno String path = "/ storage / sdcard0 / myfile.txt";
    2. path="/storage/sdcard1/myfile.txt"; ruta de acceso para el almacenamiento externo path="/storage/sdcard1/myfile.txt";
    3. Mencionar permisos en el archivo de manifiesto.

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

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

    1. Primero compruebe la longitud del archivo para confirmarlo.
    2. Compruebe las rutas de acceso en ES File Explorer con respecto a sdcard0 & sdcard1 es esto mismo o bien …

    p.ej:

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

    Acabo de averiguar algo. Al menos para mi emulador de Android, tuve la tarjeta SD como '/ storage / ???? – ???? Donde cada Es una letra mayúscula o un dígito.

    Por lo tanto, si / storage / directorio tiene un directorio que es legible y que no es el directorio de almacenamiento interno, debe ser la tarjeta SD.

    ¡Mi código funcionó en mi emulador de 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. 

    Si hay una tarjeta SD, removableStoragePath tendrá su ruta de acceso. Si no lo hay, será una cadena vacía.

    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.