android - samsung - moto e no reconoce micro sd

¿Cómo puedo obtener la lista de almacenamiento externo montado del dispositivo Android?

Question

Aquí estamos desarrollando la aplicación de Android para Android TV Box. ¿Cómo puedo obtener la lista de almacenamiento externo montado como USB stick, SDCARD and SATA HDD.

Answer 1

Ahora este tema es viejo pero esto puede ayudar. Usted debe utilizar este método.

System.getenv ();

Consulte el proyecto Environment3 para acceder a todo el almacenamiento que está conectado a su dispositivo.

github.com/omidfaraji/Environment3

Answer 2

Otra alternativa.

Primero obtén todos los archivos externos dirs

File[] externalStorageFiles=ContextCompat.getExternalFilesDirs(this,null);

Entonces llama a esta función para cada una de las carpetas.

private static String getRootOfExternalStorage(File file)
{
    if (file == null)
        return null;
    String path = file.getAbsolutePath();
    return path.replaceAll("/Android/data/" + getPackageName() + "/files", "");
}

Answer 3

Para obtener todas las carpetas de almacenamiento externo disponibles (incluidas las tarjetas SD), puede usar esto:

File[] externalStorageFiles=ContextCompat.getExternalFilesDirs(this,null);

Para ir a la "raíz" de cada almacenamiento externo (el que es la ruta de la carpeta de montaje real), puede usar esta función que he creado:

  /** Given any file/folder inside an sd card, this will return the path of the sd card */
  private static String getRootOfInnerSdCardFolder(File file)
    {
    if(file==null)
      return null;
    final long totalSpace=file.getTotalSpace();
    while(true)
      {
      final File parentFile=file.getParentFile();
      if(parentFile==null||parentFile.getTotalSpace()!=totalSpace)
        return file.getAbsolutePath();
      file=parentFile;
      }
    }

Answer 4

Puede usar getExternalStorageDirectory() para obtener el directorio de almacenamiento externo. La documentación proporciona una buena explicación de su uso http://developer.android.com/reference/android/os/Environment.html#getExternalStorageDirectory%28%29

Para dispositivos USB, probablemente tenga que buscar en la clase UsbManager o, en general, android.hardware.usb http://developer.android.com/reference/android/hardware/usb/UsbManager.html

Answer 5

Uso el archivo / proc / mounts para obtener la lista de opciones de almacenamiento disponibles

public class StorageUtils {

    private static final String TAG = "StorageUtils";

    public static class StorageInfo {

        public final String path;
        public final boolean readonly;
        public final boolean removable;     
        public final int number;

        StorageInfo(String path, boolean readonly, boolean removable, int number) {
            this.path = path;
            this.readonly = readonly;
            this.removable = removable;         
            this.number = number;
        }

        public String getDisplayName() {
            StringBuilder res = new StringBuilder();
            if (!removable) {
                res.append("Internal SD card");
            } else if (number > 1) {
                res.append("SD card " + number);
            } else {
                res.append("SD card");
            }
            if (readonly) {
                res.append(" (Read only)");
            }
            return res.toString();
        }
    }

    public static List<StorageInfo> getStorageList() {

        List<StorageInfo> list = new ArrayList<StorageInfo>();
        String def_path = Environment.getExternalStorageDirectory().getPath();
        boolean def_path_removable = Environment.isExternalStorageRemovable();
        String def_path_state = Environment.getExternalStorageState();
        boolean def_path_available = def_path_state.equals(Environment.MEDIA_MOUNTED)
                                    || def_path_state.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
        boolean def_path_readonly = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY);

        HashSet<String> paths = new HashSet<String>();
        int cur_removable_number = 1;

        if (def_path_available) {
            paths.add(def_path);
            list.add(0, new StorageInfo(def_path, def_path_readonly, def_path_removable, def_path_removable ? cur_removable_number++ : -1));
        }

        BufferedReader buf_reader = null;
        try {
            buf_reader = new BufferedReader(new FileReader("/proc/mounts"));
            String line;
            Log.d(TAG, "/proc/mounts");
            while ((line = buf_reader.readLine()) != null) {
                Log.d(TAG, line);
                if (line.contains("vfat") || line.contains("/mnt")) {
                    StringTokenizer tokens = new StringTokenizer(line, " ");
                    String unused = tokens.nextToken(); //device
                    String mount_point = tokens.nextToken(); //mount point
                    if (paths.contains(mount_point)) {
                        continue;
                    }
                    unused = tokens.nextToken(); //file system
                    List<String> flags = Arrays.asList(tokens.nextToken().split(",")); //flags
                    boolean readonly = flags.contains("ro");

                    if (line.contains("/dev/block/vold")) {
                        if (!line.contains("/mnt/secure")
                            && !line.contains("/mnt/asec")
                            && !line.contains("/mnt/obb")
                            && !line.contains("/dev/mapper")
                            && !line.contains("tmpfs")) {
                            paths.add(mount_point);
                            list.add(new StorageInfo(mount_point, readonly, true, cur_removable_number++));
                        }
                    }
                }
            }

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (buf_reader != null) {
                try {
                    buf_reader.close();
                } catch (IOException ex) {}
            }
        }
        return list;
    }
}

Answer 6

Environment.getExternalStorageState() devuelve la ruta al punto de montaje SD interno como "/ mnt / sdcard"

No, Environment.getExternalStorageDirectory() refiere a lo que el fabricante del dispositivo considere como "almacenamiento externo". En algunos dispositivos, se trata de medios extraíbles, como una tarjeta SD. En algunos dispositivos, esta es una parte del flash en el dispositivo. Aquí, "almacenamiento externo" significa "las cosas a las que se puede acceder a través del modo de almacenamiento masivo USB cuando se monta en una máquina host", al menos para Android 1.xy 2.x.

Pero la pregunta es sobre SD externa. ¿Cómo obtener una ruta como "/ mnt / sdcard / external_sd" (puede diferir de un dispositivo a otro)?

Android no tiene el concepto de "SD externo", aparte del almacenamiento externo, como se describe anteriormente.

Si el fabricante de un dispositivo eligió tener un dispositivo de almacenamiento externo a bordo y también tiene una tarjeta SD, deberá ponerse en contacto con ese fabricante para determinar si puede usar la tarjeta SD (no está garantizada) y cuáles son las reglas para usándolo, como qué ruta usar para él.

Probar esto:

Manifest.xml:

<receiver android:name=".MyReceiver">
    <intent-filter>
         <action android:name="android.intent.action.ums_connected" />
     </intent-filter>
  </receiver>

Myreceiver

public class MyReceiver extends BroadcastReceiver{
if (intent.getAction().equalsIgnoreCase(
        "android.intent.action.UMS_CONNECTED")) {...}
}