Façon universelle d'écrire à la carte SD externe sur Android

je crois qu'il y a deux méthodes pour y parvenir:

MÉTHODE 1: ( PAS le travail 6.0 et au-dessus, en raison de modifications des autorisations)

j'utilise cette méthode depuis des années sur de nombreuses versions de périphériques sans problème. le crédit est dû à la source originale, car ce n'est pas moi qui l'ai écrit.

Il sera de retour tout monté médias (y compris Real SD Cards) dans une liste d'emplacements de répertoire de chaînes. Avec la liste, vous pouvez alors demander à l'utilisateur l'emplacement où enregistrer, etc.

vous pouvez l'appeler comme suit:

 HashSet<String> extDirs = getStorageDirectories();

méthode:

/**
 * 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éthode 2:

utiliser la bibliothèque de soutien v4

import android.support.v4.content.ContextCompat;

il suffit d'appeler ce qui suit pour obtenir une liste de File emplacements de stockage.

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

les emplacements diffèrent cependant dans l'utilisation.

renvoie les chemins absolus vers les répertoires spécifiques à l'application sur tous les les périphériques de stockage externes où l'application peut placer des fichiers persistant il possède. Ces fichiers sont internes à l'application, et généralement pas visible pour l'utilisateur en tant que média.

les dispositifs de stockage externes retournés ici sont considérés comme faisant partie intégrante le dispositif, y compris le stockage externe émulé et les médias physiques les fentes, telles que les cartes SD dans un compartiment de batterie. Le retour de chemins ne comprend pas les dispositifs transitoires, tels que les lecteurs flash USB.

une application peut stocker des données sur tout ou partie des appareils retournés. Pour exemple, une application peut choisir de stocker de gros fichiers sur l'appareil avec le la plupart de l'espace disponible

Plus D'Information on ContextCompat

ce sont comme des fichiers spécifiques à une application. Caché des autres applications.

juste une autre réponse. Cette réponse montre seulement 5.0+ parce que je crois que la réponse de Doomknight posté ici est la meilleure façon de faire pour Android 4.4 et ci-dessous.

ceci est affiché à l'origine ici ( y a-t-il un moyen d'obtenir la taille de carte SD dans Android? ) par moi pour obtenir la taille de la carte SD externe sur Android 5.0 +

pour obtenir la carte SD externe comme 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;
}

Note: je ne reçois que le "premier" carte SD externe cependant vous pouvez la modifier et retourner ArrayList<File> au lieu de File et laisser la boucle continuer au lieu d'appeler break après que le premier est trouvé.

en plus de toutes les autres bonnes réponses, je pourrais ajouter un peu plus à cette question afin qu'elle puisse donner une couverture plus large pour les lecteurs. Dans ma réponse ici, j'utiliserais 2 ressources comptables pour présenter le stockage externe.

La première ressource est de Android Programmation, Le Big Nerd Ranch Guide de la 2e édition de , chapitre 16, page 294.

le livre décrit les méthodes de base et externe fichier et répertoire. Je vais essayer de faire un résumé de ce qui pourrait être pertinente à votre question.

la partie suivante du livre:

Stockage Externe

votre photo a besoin de plus qu'une place sur l'écran. Les photos grand format sont trop grandes pour coller à l'intérieur d'un Base de données SQLite, beaucoup moins un Intent . Ils auront besoin d'un endroit pour vivre dans votre système de fichiers. Normalement, vous les mettriez dans votre entrepôt privé. Rappelons que vous avez utilisé votre stockage privé pour sauvegarder votre base de données SQLite. Avec des méthodes comme Context.getFileStreamPath(String) et Context.getFilesDir() , vous pouvez faire la même chose avec les fichiers ordinaires, trop (qui vivent dans une subfolder adjacent aux bases de données subfolder your SQLite database lives in)

de Base de fichier et de répertoire des méthodes de Contexte

| 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 vous stockez des fichiers que seul votre application doit utiliser, ces méthodes sont exactement ce que vous avez besoin d'.

par contre, si vous avez besoin d'une autre application pour écrire ces fichiers, vous n'avez pas de chance: alors que Il ya un Context.MODE_WORLD_READABLE drapeau que vous pouvez passer à openFileOutput(String, int) , il est dépréciée, et pas complètement fiable dans ses effets sur les nouveaux appareils. Si vous stockez des fichiers à partager avec d'autres applications ou la réception de fichiers à partir d'autres applications (fichiers comme des images stockées), vous avez besoin de les stocker sur stockage externe à la place.

Il existe deux types de stockage externe: primaire, et tout le reste. Tous les appareils Android ont à moins un emplacement pour le stockage externe: l'emplacement principal, qui est situé dans le dossier renvoyé par Environment.getExternalStorageDirectory() . C'est peut-être une carte SD, mais aujourd'hui c'est plus souvent intégré dans l'appareil lui-même. Certains appareils peuvent avoir un stockage externe supplémentaire. Que tomberait sous " tout le reste."

contexte fournit pas mal de méthodes pour obtenir à l'extérieur de stockage, aussi. Ces méthodes fournissent facile les moyens d'obtenir à votre stockage externe primaire, et en quelque sorte-des moyens faciles à obtenir à tout le reste. Tout ces méthodes stockent des fichiers dans des endroits accessibles au public, aussi, soyez prudent avec eux.

méthodes de fichiers externes et de répertoires dans contexte

| 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.                                                                         |

techniquement, les dossiers externes fournis ci-dessus peuvent ne pas être disponibles, car certains appareils utilisent une carte SD amovible pour de stockage externe. Dans la pratique, cela est rarement un problème, parce que presque tous les appareils modernes ont un stockage interne non amovible pour leur stockage "externe". Il ne vaut donc pas la peine d'aller à des longueurs extrêmes pour en tenir compte. Mais nous avons recommandé d'inclure un code simple pour se prémunir contre cette possibilité, ce que vous ferez dans un instant.

autorisation de stockage externe

en général, vous avez besoin d'une permission pour écrire ou lire de stockage externe. Les Permissions sont des valeurs de chaîne bien connues que vous mettez dans votre manifeste en utilisant la balise <uses-permission> . Ils disent à Androïde que vous voulez faire quelque chose pour lequel Androïde veut que vous demandiez la permission.

ici, Android s'attend à ce que vous demandez la permission parce qu'il veut imposer une certaine responsabilité. Vous dites à Android que vous avez besoin d'accéder au stockage externe, et Android va ensuite dire à l'utilisateur que c'est l'une des choses que votre application fait quand ils essaient de l'installer. De cette façon, personne n'est surpris lorsque vous commencez à sauvegarder des choses sur leur carte SD.

dans Android 4.4, KitKat, ils ont assoupli cette restriction. Depuis Context.getExternalFilesDir(String) renvoie un dossier qui est spécifique à votre application, il est logique que vous voulez être en mesure de lire et d'écrire des fichiers qui y vivent. Donc sur Android 4.4 (API 19) et plus, vous n'avez pas besoin de cette permission pour ce dossier. (Mais vous avez encore besoin pour d'autres types de stockage externe.)

ajouter une ligne à votre manifeste qui demande la permission de lire le stockage externe, mais seulement jusqu'à la liste API 16.5 demander la permission de stockage externe ( 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" />

l'attribut maxSdkVersion fait en sorte que votre application ne demande cette permission que sur les versions D'Android qui sont plus anciennes que API 19, Android KitKat. Notez que vous ne demandez qu'à lire le stockage externe. Il y a aussi une permission WRITE_EXTERNAL_STORAGE , mais vous n'avez pas besoin il. Vous n'écrirez rien au stockage externe: l'application caméra le fera pour vous

la deuxième ressource est ce lien lisez tout, mais vous pouvez aussi sauter à en utilisant le stockage externe section.

référence:

• Options De Stockage Android: https://developer.android.com/guide/topics/data/data-storage.html
• site web du Livre: https://www.bignerdranch.com/we-write/android-programming

plus d'informations:

• 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
• Comment puis-je obtenir un chemin de carte SD externe pour Android 4.0+?

Avertissement: Ce l'information a été tirée de Android Programming: The Big Nerd Ranch Guide avec la permission des auteurs. Pour plus d'informations sur ce livre ou pour acheter un exemplaire, veuillez visiter bignerdranch.com.

ce sujet est un peu ancien mais je cherchais une solution et après quelques recherches je suis venu avec le code ci-dessous pour récupérer une liste de points de montage" externes " disponibles qui, selon ma connaissance, fonctionne sur de nombreux appareils différents.

essentiellement, il lit les points de montage disponibles, filtre ceux qui sont invalides, teste le reste s'ils sont accessibles et les ajoute si toutes les conditions sont remplies.

bien sûr, les permissions requises doivent être accordé avant que le code ne soit invoqué.

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

Voici une façon de créer un nouveau fichier dans le stockage externe (SDCard si présent dans le périphérique ou le stockage externe du périphérique si non). Il suffit de remplacer "foldername" par le nom du dossier de destination désiré et "filename" par le nom du fichier que vous sauvegardez. Bien sûr, Ici vous pouvez voir comment enregistrer un fichier Générique, maintenant vous pouvez rechercher comment enregistrer des images peut-être ici ou quoi que ce soit dans un fichier.

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

cette commande également que fichier existe et ajoute un nombre à la fin du nom du nouveau fichier pour l'enregistrer.

Espère que cela aide!

EDIT: Désolé, j'ai oublié que vous devez demander <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> dans votre manifeste (ou par programme si vous préférez la guimauve)

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

sortie:

`D/MainActivity: /storage/extSdCard`

Travailler sur le Note 3 Android 5.0.

pour les versions sous Marshmallow vous pouvez directement donner les permissions dans le manifeste.

mais pour les appareils avec Marshmallow et au-dessus vous devez accorder les permissions sur le temps d'exécution.

en utilisant

Environment.getExternalStorageDirectory();

vous pouvez accéder directement à la carte SD externe (monté un) Espérons que cette aide.