Forma universal de escribir en la tarjeta SD externa en Android

Creo que hay dos métodos para lograr esto:

MÉTODO 1: (NO funciona en la versión 6.0 y superior, debido a cambios en los permisos)

He estado usando este método durante años en muchas versiones de dispositivos sin ningún problema. El crédito se debe a la fuente original, ya que no fui yo quien lo escribió.

Devolverá todos los medios montados (incluidas las tarjetas SD Reales) en una lista de ubicaciones de directorios de cadenas. Con la lista puede preguntar al usuario dónde guardar, etc.

Puedes llamarlo con lo siguiente:

 HashSet<String> extDirs = getStorageDirectories();

Método:

/**
 * Returns all the possible SDCard directories
 */
public static HashSet<String> getStorageDirectories() {
    final HashSet<String> out = new HashSet<String>();
    String reg = "(?i).*vold.*(vfat|ntfs|exfat|fat32|ext3|ext4).*rw.*";
    String 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 String(buffer);
        }
        is.close();
    } catch (final Exception e) {
        e.printStackTrace();
    }

    // parse output
    final String[] lines = s.split("\n");
    for (String line : lines) {
        if (!line.toLowerCase().contains("asec")) {
            if (line.matches(reg)) {
                String[] parts = line.split(" ");
                for (String part : parts) {
                    if (part.startsWith("/"))
                        if (!part.toLowerCase().contains("vold"))
                            out.add(part);
                }
            }
        }
    }
    return out;
}

MÉTODO 2:

Utilice la biblioteca de soporte v4

import android.support.v4.content.ContextCompat;

Simplemente llame a lo siguiente para obtener una lista de File ubicaciones de almacenamiento.

 File[] list = ContextCompat.getExternalFilesDirs(myContext, null);

Sin embargo, las ubicaciones difieren en el uso.

Devuelve rutas absolutas a directorios específicos de la aplicación en todos dispositivos de almacenamiento externo donde la aplicación puede colocar archivos persistentes le pertenece. Estos los archivos son internos de la aplicación, y normalmente no visible para el usuario como medio.

Los dispositivos de almacenamiento externo devueltos aquí se consideran una parte permanente de el dispositivo, incluyendo tanto el almacenamiento externo emulado como los medios físicos ranuras, como tarjetas SD en un compartimiento de baterías. Las rutas devueltas hacen no incluya dispositivos transitorios, como unidades flash USB.

Una aplicación puede almacenar datos en cualquiera o todos los dispositivos devueltos. Para por ejemplo, una aplicación puede optar por almacenar archivos de gran tamaño en el espacio más disponible

Más información sobre ContextCompat

Son como archivos específicos de la aplicación. Oculto de otras aplicaciones.

Solo otra respuesta. Esta respuesta solo muestra 5.0 + porque creo que la respuesta de Doomknight publicada aquí es la mejor manera de hacerlo para Android 4.4 y por debajo.

Esto se publicó originalmente aquí (Hay una manera de obtener el tamaño de la tarjeta SD en Android?) por mí para obtener el tamaño de la tarjeta SD externa en Android 5.0 +

Para obtener la tarjeta SD externa como un File:

public File getExternalSdCard() {
    File externalStorage = null;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        File storage = new File("/storage");

        if(storage.exists()) {
            File[] files = storage.listFiles();

            for (File file : files) {
                if (file.exists()) {
                    try {
                        if (Environment.isExternalStorageRemovable(file)) {
                            externalStorage = file;
                            break;
                        }
                    } catch (Exception e) {
                        Log.e("TAG", e.toString());
                    }
                }
            }
        }
    } else {
        // do one of many old methods
        // I believe Doomsknight's method is the best option here
    }

    return externalStorage;
}

Nota: Solo obtengo la" primera " tarjeta sd externa, sin embargo, puede modificarla y devolver ArrayList<File> en lugar de File y dejar el bucle continúa en lugar de llamar break después de que se encuentre el primero.

Además de todas las otras respuestas agradables, podría agregar un poco más a esta pregunta para que pueda dar una cobertura más amplia para los lectores. En mi respuesta aquí, usaría 2 recursos contables para presentar Almacenamiento externo.

El primer recurso es de Android Programming, The Big Nerd Ranch Guide 2nd edition, capítulo 16, página 294.

El libro describe los métodos básicos y externos de archivo y directorio. Voy a tratar de hacer un currículum de lo que podría ser relevante para su pregunta.

La siguiente parte del libro:

Almacenamiento externo

Su foto necesita más que un lugar en la pantalla. Imágenes de tamaño completo son demasiado grandes para pegarse dentro de un Base de datos SQLite, mucho menos un Intent. Necesitarán un lugar para vivir en el sistema de archivos de su dispositivo. Normalmente, los pondrías en tu almacenamiento privado. Recuerde que utilizó su almacenamiento privado para guardar su base de datos SQLite. Con métodos como Context.getFileStreamPath(String) y Context.getFilesDir(), puedes hacer lo mismo con archivos regulares, también (que vivirán en un subcarpeta adyacente a la subcarpeta de bases de datos en la que vive su base de datos SQLite)

Métodos básicos de archivo y directorio en Contexto

| Method                                                                                |
|---------------------------------------------------------------------------------------|
|File etFilesDir()                                                                      |
| - Returns a handle to the directory for private application files.                    |
|                                                                                       |
|FileInputStream openFileInput(String name)                                             |
| - Opens an existing file for input (relative to the files directory).                 |
|                                                                                       |
|FileOutputStream openFileOutput(String name, int mode)                                 |
| - Opens a file for output, possibly creating it (relative to the files directory).    |
|                                                                                       |
|File getDir(String name, int mode)                                                     |
| - Gets (and possibly creates) a subdirectory within the files directory.              |
|                                                                                       |
|String[] fileList()                                                                    |
| - Gets a list of file names in the main files directory, such as for use with         |
|   openFileInput(String).                                                              |
|                                                                                       |
|File getCacheDir()                                                                     |
| - Returns a handle to a directory you can use specifically for storing cache files.   |
|   You should take care to keep this directory tidy and use as little space as possible|

Si está almacenando archivos que solo su aplicación actual necesita usar, estos métodos son exactamente lo que lo necesitas.

Por otro lado, si necesitas otra aplicación para escribir en esos archivos, no tienes suerte: mientras hay una bandera Context.MODE_WORLD_READABLE que puede pasar a openFileOutput(String, int), es ser obsoleto, y no completamente fiable en sus efectos en los dispositivos más nuevos. Si está almacenando archivos para compartir con otras aplicaciones o recibiendo archivos de otras aplicaciones( archivos como imágenes almacenadas), debe almacenarlos en almacenamiento externo en su lugar.

Hay dos tipos de almacenamiento externo: primario y todo lo demás. Todos los dispositivos Android tienen en al menos una ubicación para el almacenamiento externo: la ubicación principal, que se encuentra en la carpeta devuelta por Environment.getExternalStorageDirectory(). Esto puede ser una tarjeta SD, pero hoy en día es más comúnmente integrado en el propio dispositivo. Algunos dispositivos pueden tener almacenamiento externo adicional. Que caería bajo " todo lo demás."

El contexto también proporciona bastantes métodos para acceder al almacenamiento externo. Estos métodos proporcionan fácil maneras de llegar a su almacenamiento externo principal, y un poco-sorta-maneras fáciles de llegar a todo lo demás. Todos estos métodos también almacenan archivos en lugares disponibles públicamente, así que tenga cuidado con ellos.

Archivo Externo y métodos de directorio en Contexto

| Method                                                                                |
| --------------------------------------------------------------------------------------|
|File getExternalCacheDir()                                                             |
| - Returns a handle to a cache folder in primary external storage. Treat it like you do|
|   getCacheDir(), except a little more carefully. Android is even less likely to clean |
|   up this folder than the private storage one.                                        |
|                                                                                       |
|File[] getExternalCacheDirs()                                                          |
| - Returns cache folders for multiple external storage locations.                      |
|                                                                                       |
|File getExternalFilesDir(String)                                                       |
| - Returns a handle to a folder on primary external storage in which to store regular  |
|   files. If you pass in a type String, you can access a specific subfolder dedicated  |
|   to a particular type of content. Type constants are defined in Environment, where   |
|   they are prefixed with DIRECTORY_.                                                  |
|   For example, pictures go in Environment.DIRECTORY_PICTURES.                         |
|                                                                                       |
|File[] getExternalFilesDirs(String)                                                    |
| - Same as getExternalFilesDir(String), but returns all possible file folders for the  |
|   given type.                                                                         |
|                                                                                       |
|File[] getExternalMediaDirs()                                                          |
| - Returns handles to all the external folders Android makes available for storing     |
|   media – pictures, movies, and music. What makes this different from calling         |
|   getExternalFilesDir(Environment.DIRECTORY_PICTURES) is that the media scanner       |
|   automatically scans this folder. The media scanner makes files available to         |
|   applications that play music, or browse movies and photos, so anything that you     |
|   put in a folder returned by getExternalMediaDirs() will automatically appear in     |
|   those apps.                                                                         |

Técnicamente, las carpetas externas proporcionadas anteriormente pueden no estar disponibles, ya que algunos dispositivos utilizan una tarjeta SD extraíble para el almacenamiento externo. En la práctica, esto rara vez es un problema, porque casi todos los dispositivos modernos tienen almacenamiento interno no extraíble para su almacenamiento "externo". Así que no vale la pena ir a extremos extremos para dar cuenta de ello. Pero recomendamos incluir código simple para evitar la posibilidad, lo que hará en un momento.

Permiso de almacenamiento externo

En general, necesita un permiso para escribir o leer desde un almacenamiento externo. Los permisos son valores de cadena bien conocidos que pones en tu manifiesto usando la etiqueta <uses-permission>. Dicen Android que quieres hacer algo que Android quiere que pedir permiso para.

Aquí, Android espera que le pidas permiso porque quiere hacer cumplir alguna responsabilidad. Le dices a Android que necesitas acceder al almacenamiento externo, y Android le dirá al usuario que esta es una de las cosas que hace tu aplicación cuando intentan instalarla. De esa manera, nadie se sorprende cuando comienza a guardar cosas en su tarjeta SD.

En Android 4.4, KitKat, aflojaron esta restricción. Dado que Context.getExternalFilesDir(String) devuelve una carpeta que es específica para su aplicación, tiene sentido que desee poder leer y escribir archivos que viven allí. Así que en Android 4.4 (API 19) y arriba, usted no necesita este permiso para esta carpeta. (Pero todavía lo necesita para otros tipos de almacenamiento externo.)

Agregue una línea a su manifiesto que solicita el permiso para leer almacenamiento externo, pero solo hasta la lista de API 16.5 Que solicita permiso de almacenamiento externo(AndroidManifest.xml)

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.bignerdranch.android.criminalintent" >
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="18" />

El atributo maxSdkVersion hace que tu aplicación solo solicite este permiso en versiones de Android que sean anteriores a API 19, Android KitKat. Tenga en cuenta que solo está pidiendo leer el almacenamiento externo. También hay un permiso WRITE_EXTERNAL_STORAGE, pero no lo necesitas. No escribirás nada en el almacenamiento externo: La aplicación de la cámara lo hará por ti

El segundo recurso es este enlace léalo todo, pero también puede saltar a Usando la sección Almacenamiento externo.

Referencia:

• Opciones de almacenamiento de Android: https://developer.android.com/guide/topics/data/data-storage.html
• Sitio del libro: https://www.bignerdranch.com/we-write/android-programming

Leer Más cosas:

• https://developer.android.com/reference/android/os/Environment.html#getExternalStoragePublicDirectory%28java.lang.String%29
• https://developer.android.com/reference/android/os/Environment.html#DIRECTORY_PICTURES
• https://developer.android.com/reference/android/os/Environment.html#DIRECTORY_MOVIES
• ¿Cómo puedo obtener la ruta de la tarjeta SD externa para Android 4.0+?

Descargo de responsabilidad: Esta información fue tomada de Android Programming: The Big Nerd Ranch Guide con el permiso de los autores. Para obtener más información sobre este libro o para comprar una copia, visite bignerdranch.com.

Este tema es un poco viejo, pero estaba buscando una solución y después de algunas investigaciones, vine con el código a continuación para recuperar una lista de puntos de montaje "externos" disponibles que, según mi conocimiento, funciona en muchos dispositivos diferentes.

Básicamente, lee los puntos de montaje disponibles, filtra los no válidos, prueba el resto si son accesibles y los agrega si se cumplen todas las condiciones.

Por supuesto, los permisos requeridos deben ser otorgados antes de que el código sea invocar.

// Notice: FileSystemDevice is just my own wrapper class. Feel free to replace it with your own. 

private List<FileSystemDevice> getDevices() {

    List<FileSystemDevice> devices = new ArrayList<>();

    // Add default external storage if available.
    File sdCardFromSystem = null;
    switch(Environment.getExternalStorageState()) {
        case Environment.MEDIA_MOUNTED:
        case Environment.MEDIA_MOUNTED_READ_ONLY:
        case Environment.MEDIA_SHARED:
            sdCardFromSystem = Environment.getExternalStorageDirectory();
            break;
    }

    if (sdCardFromSystem != null) {
        devices.add(new FileSystemDevice(sdCardFromSystem));
    }

    // Read /proc/mounts and add all mount points that are available
    // and are not "special". Also, check if the default external storage
    // is not contained inside the mount point. 
    try {
        FileInputStream fs = new FileInputStream("/proc/mounts");
        String mounts = IOUtils.toString(fs, "UTF-8");
        for(String line : mounts.split("\n")) {
            String[] parts = line.split(" ");

            // parts[0] - mount type
            // parts[1] - mount point
            if (parts.length > 1) {
                try {

                    // Skip "special" mount points and mount points that can be accessed
                    // directly by Android's functions. 
                    if (parts[0].equals("proc")) { continue; }
                    if (parts[0].equals("rootfs")) { continue; }
                    if (parts[0].equals("devpts")) { continue; }
                    if (parts[0].equals("none")) { continue; }
                    if (parts[0].equals("sysfs")) { continue; }
                    if (parts[0].equals("selinuxfs")) { continue; }
                    if (parts[0].equals("debugfs")) { continue; }
                    if (parts[0].equals("tmpfs")) { continue; }
                    if (parts[1].equals(Environment.getRootDirectory().getAbsolutePath())) { continue; }
                    if (parts[1].equals(Environment.getDataDirectory().getAbsolutePath())) { continue; }
                    if (parts[1].equals(Environment.getExternalStorageDirectory().getAbsolutePath())) { continue; }

                    // Verify that the mount point is accessible by listing its content. 
                    File file = new File(parts[1]);
                    if (file.listFiles() != null) {
                        try {

                            // Get canonical path for case it's just symlink to another mount point.
                            String devPath = file.getCanonicalPath();

                            for(FileSystemDevice device : devices) {

                                if (!devices.contains(devPath)) {                        
                                    devices.add(new FileSystemDevice(new File(devPath)));
                                }

                            }
                        } catch (Exception e) {
                            // Silently skip the exception as it can only occur if the mount point is not valid. 
                            e.printStackTrace();
                        }
                    }
                } catch (Exception e) {
                    // Silently skip the exception as it can only occur if the mount point is not valid. 
                    e.printStackTrace();
                }
            }
        }

        fs.close();
    } catch (FileNotFoundException e) {
        // Silently skip the exception as it can only occur if the /proc/mounts file is unavailable. 
        // Possibly, another detection method can be called here.
        e.printStackTrace();
    } catch (IOException e) {
        // Silently skip the exception as it can only occur if the /proc/mounts file is unavailable.
        // Possibly, another detection method can be called here.
        e.printStackTrace();            
    }

    return devices;
}

Aquí hay una forma de crear un nuevo archivo en el almacenamiento externo (Tarjeta SD si está presente en el dispositivo o dispositivo de almacenamiento externo si no). Simplemente reemplace " foldername "con el nombre de la carpeta de destino deseada y" filename " con el nombre del archivo que está guardando. Por supuesto, aquí puede ver cómo guardar un archivo genérico, ahora puede buscar cómo guardar imágenes tal vez aquí o lo que sea en un archivo.

try {
            File dir =  new File(Environment.getExternalStorageDirectory() + "/foldername/");
            if (!dir.exists()){
                dir.mkdirs();
            }
            File sdCardFile = new File(Environment.getExternalStorageDirectory() + "/foldername/" + fileName );
            int num = 1;
            String fileNameAux = fileName;
            while (sdCardFile.exists()){
                fileNameAux = fileName+"_"+num;
                sdCardFile = new File(Environment.getExternalStorageDirectory() + "/foldername/" + fileNameAux);
                num++;
            }

Esto también controla que el archivo existe y agrega un número al final de el nombre del nuevo archivo para guardarlo.

Espero que ayude!

EDITAR: Lo siento, olvidé que tienes que pedir <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> en tu manifiesto (o programáticamente si lo prefiere de Malvavisco)

 
`Log.d(TAG, System.getenv("SECONDARY_STORAGE"));`

Salida:

`D/MainActivity: /storage/extSdCard`

Trabajando en Note 3 Android 5.0.

Para las versiones por debajo de Marshmallow puede dar directamente los permisos en el manifiesto.

Pero para los dispositivos con Marshmallow y superior necesita otorgar los permisos en tiempo de ejecución.

Usando

Environment.getExternalStorageDirectory();

Puede acceder directamente a la tarjeta SD externa (Montada una) Espero que esto ayude.