Discussion :

[jlalexie]

Bonjour,

J'ai un Galaxy S5, Android 5.1, connecté à mon PC en usb, donc je teste directement. J'utilise Android Studio.
J'ai créé une appli qui doit stocker des images sur la carte SD externe.
Dans mon manifeste, j'ai mis l'autorisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Je crée le fichier en utilisant le chemin de la SD externe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
File f = new File(Environment.getExternalStorageDirectory()+ File.separator + "test8.jpg");

Au final, il écrit dans la mémoire interne sur la "racine".
En visualisant le contenu du chemin j'ai ceci: "/storage/emulated/0/test8.jpg".
Je suppose que cela vient du "réglage" d'Android Studio ou bien faut-il que l'appli soit sur la carte SD externe ?

Merci pour votre aide.

[jlalexie]

J'ai essayé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
File f = new File( "/storage/extSdCard/test8.jpg");

maia ça plante l'appli.

[ChPr]

Il semble que le nom qui permet d'identifier la carte SD n'est pas le même d'une marque à l'autre et ainsi qu'au sein même d'une marque.

On m'avait préconisé la méthode suivante (qui s'avère efficace avec mon Samsung GlaxY S2 et mon Archos 7b Titanium) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    public static String SecondStorage() {
        Map envs = System.getenv();
        Set keys = envs.keySet();
        Iterator i = keys.iterator();
        String res = null;
        while (i.hasNext()) {
            String k = (String) i.next();
            String v = (String) envs.get(k);
            if (k.contains("SECOND") && k.contains("STORAGE")) {
                int f = v.indexOf(":");
                if (f < 0)
                    res = v;
                else
                    res = v.substring(0, f);
                break;
            }
        }
        return res;
    }
 
    public static File defRep(String rep) {
        File sdCard = Environment.getExternalStorageDirectory();
         dirSvg = new File(SecondStorage());
        if (dirSvg.exists())
            dirSvg = new File(dirSvg.getAbsolutePath(), rep);
        else
            dirSvg = new File(sdCard.getAbsolutePath(), rep);
        dirSvg.mkdir();
        return dirSvg;
    }

Cordialement.

Pierre

[sevyc64]

Pour ma part (sony Z3 C) lorsque je transfère les applications du localstorage vers l'externalstorage avec les fonctions de bases d'Android (ou de la surcouche, je sais pas), elles sont transférées vers /storage/emulated/0/

Or il s'avère que /storage/emulated/0/ est en réalité la mémoire flash interne du smartphone, la carte SD externe étant monté en /storage/emulated/1/.

Je n'avais pas ce problème avec Kitkat, je n'ai pas souvenir de l'avoir eu avec lolipop 5.0.1, mais je l'ai bien avec la 5.1.1. Et vu quelques messages que j'ai pu voir sur des forums je ne suis pas le seul dans ce cas.

[nicroman]

Le code ci-dessus est un peu bizarre... pour "trouver" la carte SD externe il faut parcourir les "mount-points" et en trouver un qui ne soit pas celui par défaut. Je vais essayer de retrouver le code en question, mais il est bien plus complexe que ça...

Le support des cartes SD externes n'est pas *assuré* par Android.
getExternalStorageDirectory, contrairement à ce que son nom laisse croire, permet d'avoir le répertoire racine de ce qui est visible *quand le téléphone est considéré comme disque SD* (branché en USB sur un ordi par exemple).
Et il y a 100% de chance que ce truc soit sur la mémoire interne du device (puisqu'il peut ne pas y avoir de carte SD additionelle).

En prime, depuis Android 5, cette carte "externe" est en lecture seule pour les applications (seul le système y a accès en écriture) il me semble.

[sevyc64]

En prime, depuis Android 5, cette carte "externe" est en lecture seule pour les applications (seul le système y a accès en écriture) il me semble.

Oui, et c'est bien pénible d'ailleurs. Je en comprend pas pourquoi une telle restriction alors que l'on sait que les cartes internes sont limitées (très, parfois) en taille.
Ensuite certaines application arrivent à y écrire (les gestionnaires de fichiers notamment mais pas que), d'autres non.
Ensuite certaines y arrivaient avec la 5.0.1 mais plus avec la 5.1.

[grunk]

Depuis android 4.4 les développeurs n'ont plus la permission d'écrire n'importe comment sur la carte SD ...
Voir http://developer.android.com/guide/t...#filesExternal et les notes dédié à Kitkat et +

[Feanorin]

Après tu peux toujours passer par les commandes shell pour trouver les devices monté depuis le dossier
/proc/mounts ou /etc/system/vold.fstab normalement.

Après il vaut mieux utiliser les fonctions que te proposent grunk,car il faudra sinon que tu vérifié les droits sur la sdcard ( comment elle est monté ).

[jlalexie]

Merci pour vos réponses.
Au vu de la complexité de la situation, je crois que je vais rester sur la mémoire interne, mon appli devant tourner sur plusieurs version d'Android.

[mllibre]

Bonjour,
Depuis un certain temps je n'arrive plus à écrire sur la carte externe de mon smartphone (Galaxy Note 2 - Android 4.4.2). Il semble en effet que ce ne soit plus possible depuis les applis d'utilisateurs ordinaires.
Je vous soumets un petit programme simple et complet de test d'écriture de fichiers, en espérant que quelqu'un pourra nous faire progresser, ou nous confirmer qu'il n'y a rien à espérer pour le moment.
Dans ce programme j'écris un petit texte d'abord dans un fichier bidon1.txt dans la zone externe privée, puis un fichier bidon2.txt dans la zone externe publique, puis un fichier bidon3.txt sur la carte externe (supplémentaire).
Les 2 premiers sont bien écrits, mais il y a échec de création du troisième.
(Tout ceci ne concerne que l'accès en écriture car en lecture il n'y a pas de problème).

Vous trouverez ci-après le source java de l'activité (pas de layout.xml), le manifeste, la sortie d'un Log et une session adb shell de vérification avec laquelle on arrive à créer sans problème des fichiers sur la carte externe.

Source java de l'activité :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package fr.llibre.testwrite;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
 
public class MainActivity extends AppCompatActivity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        String texte = "Test n°4 écriture dans divers fichiers.\n";
        // Test écriture dans la mémoire externe privée
        File dirExtPriv = getExternalFilesDir(null); // Le répertoire parent externe privé de l'appli
        File fichBidon1 = new File(dirExtPriv, "bidon1.txt"); // Un fichier texte bidon
        texte += "Ecriture fichier " + fichBidon1.getAbsolutePath() + " (répertoire ext. privé).\n";
        try {
            FileWriter fw = new FileWriter(fichBidon1); // On crée le fichier en mode écriture
            try {
                fw.write(texte, 0, texte.length());				// On l'écrit dans le fichier
                fw.close();										// On le ferme.
                texte += "L'écriture semble avoir réussie.\n";
            } catch (IOException e) { texte += "L'écriture a échouée !\n"; fw.close();}
        } catch (IOException e) { texte += "Echec ouverture du fichier !\n";}
        // Test écriture dans la mémoire externe publique
        File dirExtPub = Environment.getExternalStorageDirectory();
        File fichBidon2 = new File(dirExtPub, "bidon2.txt"); // Un fichier texte bidon
        texte += "Ecriture fichier " + fichBidon2.getAbsolutePath() + " (répertoire ext. public).\n";
        try {
            FileWriter fw = new FileWriter(fichBidon2); // On crée le fichier en mode écriture
            try {
                fw.write(texte, 0, texte.length());				// On l'écrit dans le fichier
                fw.close();										// On le ferme.
                texte += "L'écriture semble avoir réussie.\n";
            } catch (IOException e) { texte += "L'écriture a échouée !\n"; fw.close();}
        } catch (IOException e) { texte += "Echec ouverture du fichier !\n";}
        // Test écriture sur la carte externe
        String extSdCardPath = System.getenv("SECONDARY_STORAGE");
        if(!TextUtils.isEmpty(extSdCardPath))
        {
            File extSdCard = new File(extSdCardPath);
            if (extSdCard.isDirectory())
            {
                texte += "On a une carte externe d'adresse " + extSdCardPath +"\n";
                File fichBidon3 = new File(extSdCard, "bidon3.txt");
                texte += "Ecriture fichier " + fichBidon3.getAbsolutePath() + "(carte externe).\n";
                try {
                    FileWriter fw = new FileWriter(fichBidon3); // On crée le fichier en mode écriture
                    try {
                        fw.write(texte, 0, texte.length());				// On l'écrit dans le fichier
                        fw.close();										// On le ferme.
                        texte += "L'écriture semble avoir réussie.\n";
                    } catch (IOException e) { texte += "L'écriture a échouée !\n"; fw.close();}
                } catch (IOException e) { texte += "Echec ouverture du fichier !\n";}
            }
        }
        Log.i(getClass().getName(), texte);
        // On affiche le résultat sur le smartphone
        LinearLayout layout = new LinearLayout(this);
        TextView textView = new TextView(this);
        textView.setText(texte);
        layout.addView(textView);
        setContentView(layout);
    }
}

Manifeste Android

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="fr.llibre.testwrite" >
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity android:name=".MainActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Ci-dessous la sortie du Log, montre que toutes les écritures ont réussies sauf celle sur la carte externe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
Test n°4 écriture dans divers fichiers.
Ecriture fichier /storage/emulated/0/Android/data/fr.llibre.testwrite/files/bidon1.txt (répertoire ext. privé).
L'écriture semble avoir réussie.
Ecriture fichier /storage/emulated/0/bidon2.txt (répertoire ext. public).
L'écriture semble avoir réussie.
On a une carte externe d'adresse /storage/extSdCard
Ecriture fichier /storage/extSdCard/bidon3.txt(carte externe).
Echec ouverture du fichier !

La session shell ci-dessous, effectuée sur le smartphone avec adb, montre que le fichier bidon2.txt a bien été écrit. On remarquera que depuis ce shell l'accès au répertoire /storage/emulated/0 se fait par le chemin /mnt/shell/emulated/0.
Il n'y a pas de trace du fichier bidon3.txt dans /storage/extSdCard car l'appli n'a pas réussi à le créer. Par contre avec ce shell on crée ci-dessous le fichier /storage/extSdCard/bidon0.txt, puis on le lit, puis on le détruit, sans problème.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
E:\temp>adb shell
shell@t03g:/ $ ls -l /storage/emulated
lrwxrwxrwx root     root              2015-10-13 08:08 legacy -> /mnt/shell/emulated/0
shell@t03g:/ $ cat /mnt/shell/emulated/0/bidon2.txt
Test n°4 écriture dans divers fichiers.
Ecriture fichier /storage/emulated/0/Android/data/fr.llibre.testwrite/files/bidon1.txt (répertoire ext. privé).
L'écriture semble avoir réussie.
Ecriture fichier /storage/emulated/0/bidon2.txt (répertoire ext. public).
shell@t03g:/ $ ls -l /storage/extSdCard
drwxrwx--x root     sdcard_r          2014-08-15 17:30 Android
drwxrwx--- root     sdcard_r          2013-11-26 15:18 DCIM
drwxrwx--- root     sdcard_r          2013-04-05 19:03 LOST.DIR
drwxrwx--- root     sdcard_r          2015-05-20 11:31 Sounds
drwxrwx--- root     sdcard_r          2015-11-26 17:32 temp
shell@t03g:/ $ cd /storage/extSdCard
shell@t03g:/storage/extSdCard $ cat > bidon0.txt
Essai ecriture sur carte externe depuis adb
shell@t03g:/storage/extSdCard $ ls -l bidon0.txt
-rwxrwx--- root     sdcard_r       44 2015-11-26 21:27 bidon0.txt
shell@t03g:/storage/extSdCard $ cat bidon0.txt
Essai ecriture sur carte externe depuis adb
shell@t03g:/storage/extSdCard $ rm bidon0.txt
shell@t03g:/storage/extSdCard $ ls -l bidon0.txt
bidon0.txt: No such file or directory
1|shell@t03g:/storage/extSdCard $ exit

Remarque :
Même le gestionnaire de fichier ES Explorateur échoue à déplacer les fichiers vers la carte externe. Il semble que pour le moment la seule possibilité soit de passer par l'intermédiaire de la liaison usb avec un PC (ou autre).
Cordialement à tous.

[grunk]

Comme expliqué dans le liens de la doc que j'ai fournit précédemment tu ne peux pas écrire directement comme ça sur la carte SD.

Il faut passer soit par getExternalFilesDir(null) pour écrire dans le dossier privé de l'app sur la carte SD (qui sera supprimé à la désinstallation) ou par
getExternalStoragePublicDirectory(Environment.DIRECTORY_XXXX) pour un dossier public