Écrire un fichier dans un stockage externe sous Android
Je veux créer un fichier dans la sdCard de stockage externe et y écrire. J'ai effectué une recherche sur Internet mais je n'ai pas obtenu le résultat. code suivant et obtenir un ERRR "," Impossible de créer le fichier ".
btnWriteSDFile = (Button) findViewById(R.id.btnWriteSDFile);
btnWriteSDFile.setOnClickListener(new OnClickListener() {
//private Throwable e;
@Override
public void onClick(View v) {
// write on SD card file data from the text box
try {
File myFile = new File("/sdcard/mysdfile.txt");
myFile.createNewFile();
FileOutputStream fOut = new FileOutputStream(myFile);
OutputStreamWriter myOutWriter = new OutputStreamWriter(fOut);
myOutWriter.append(txtData.getText());
myOutWriter.close();
fOut.close();
} catch (Exception e) {
Log.e("ERRR", "Could not create file",e);
}
}// onClick
}); // btnWriteSDFile
Vous pouvez aussi le faire avec ce code.
public class WriteSDCard extends Activity {
private static final String TAG = "MEDIA";
private TextView tv;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
tv = (TextView) findViewById(R.id.TextView01);
checkExternalMedia();
writeToSDFile();
readRaw();
}
/** Method to check whether external media available and writable. This is adapted from
http://developer.Android.com/guide/topics/data/data-storage.html#filesExternal */
private void checkExternalMedia(){
boolean mExternalStorageAvailable = false;
boolean mExternalStorageWriteable = false;
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
// Can read and write the media
mExternalStorageAvailable = mExternalStorageWriteable = true;
} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
// Can only read the media
mExternalStorageAvailable = true;
mExternalStorageWriteable = false;
} else {
// Can't read or write
mExternalStorageAvailable = mExternalStorageWriteable = false;
}
tv.append("\n\nExternal Media: readable="
+mExternalStorageAvailable+" writable="+mExternalStorageWriteable);
}
/** Method to write ascii text characters to file on SD card. Note that you must add a
WRITE_EXTERNAL_STORAGE permission to the manifest file or this method will throw
a FileNotFound Exception because you won't have write permission. */
private void writeToSDFile(){
// Find the root of the external storage.
// See http://developer.Android.com/guide/topics/data/data- storage.html#filesExternal
File root = Android.os.Environment.getExternalStorageDirectory();
tv.append("\nExternal file system root: "+root);
// See http://stackoverflow.com/questions/3551821/Android-write-to-sd-card-folder
File dir = new File (root.getAbsolutePath() + "/download");
dir.mkdirs();
File file = new File(dir, "myData.txt");
try {
FileOutputStream f = new FileOutputStream(file);
PrintWriter pw = new PrintWriter(f);
pw.println("Hi , How are you");
pw.println("Hello");
pw.flush();
pw.close();
f.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
Log.i(TAG, "******* File not found. Did you" +
" add a WRITE_EXTERNAL_STORAGE permission to the manifest?");
} catch (IOException e) {
e.printStackTrace();
}
tv.append("\n\nFile written to "+file);
}
/** Method to read in a text file placed in the res/raw directory of the application. The
method reads in all lines of the file sequentially. */
private void readRaw(){
tv.append("\nData read from res/raw/textfile.txt:");
InputStream is = this.getResources().openRawResource(R.raw.textfile);
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr, 8192); // 2nd arg is buffer size
// More efficient (less readable) implementation of above is the composite expression
/*BufferedReader br = new BufferedReader(new InputStreamReader(
this.getResources().openRawResource(R.raw.textfile)), 8192);*/
try {
String test;
while (true){
test = br.readLine();
// readLine() returns null if no more lines in the file
if(test == null) break;
tv.append("\n"+" "+test);
}
isr.close();
is.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
tv.append("\n\nThat is all");
}
}
Pour écrire dans le stockage externe des périphériques Lollipop +, nous avons besoin de:
Ajoutez l’autorisation suivante dans Manifest:
<uses-permission Android:name="Android.permission.WRITE_EXTERNAL_STORAGE" />Demander une approbation à l'utilisateur:
public static final int REQUEST_WRITE_STORAGE = 112; private requestPermission(Activity context) { boolean hasPermission = (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED); if (!hasPermission) { ActivityCompat.requestPermissions(context, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_WRITE_STORAGE); } else { // You are allowed to write external storage: String path = Environment.getExternalStorageDirectory().getAbsolutePath() + "/new_folder"; File storageDir = new File(path); if (!storageDir.exists() && !storageDir.mkdirs()) { // This should never happen - log handled exception! } }Gérer la réponse de l'utilisateur dans l'activité:
@Override public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); switch (requestCode) { case Preferences.REQUEST_WRITE_STORAGE: { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(this, "The app was allowed to write to your storage!", Toast.LENGTH_LONG).show(); // Reload the activity with permission granted or use the features what required the permission } else { Toast.makeText(this, "The app was not allowed to write to your storage. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show(); } } }
Vous devriez lire la documentation sur le stockage de données externes sur Android . Votre code actuel pourrait comporter une multitude de problèmes, et j’estime que l’exploration de la documentation pourrait vous aider à les résoudre.
Le code ci-dessous crée un répertoire Documents puis un sous-répertoire pour l'application et enregistre les fichiers dans celle-ci.
public class loadDataTooDisk extends AsyncTask<String, Integer, String> {
String sdCardFileTxt;
@Override
protected String doInBackground(String... params)
{
//check to see if external storage is avalibel
checkState();
if(canW == canR == true)
{
//get the path to sdcard
File pathToExternalStorage = Environment.getExternalStorageDirectory();
//to this path add a new directory path and create new App dir (InstroList) in /documents Dir
File appDirectory = new File(pathToExternalStorage.getAbsolutePath() + "/documents/InstroList");
// have the object build the directory structure, if needed.
appDirectory.mkdirs();
//test to see if it is a Text file
if ( myNewFileName.endsWith(".txt") )
{
//Create a File for the output file data
File saveFilePath = new File (appDirectory, myNewFileName);
//Adds the textbox data to the file
try{
String newline = "\r\n";
FileOutputStream fos = new FileOutputStream (saveFilePath);
OutputStreamWriter OutDataWriter = new OutputStreamWriter(fos);
OutDataWriter.write(equipNo.getText() + newline);
// OutDataWriter.append(equipNo.getText() + newline);
OutDataWriter.append(equip_Type.getText() + newline);
OutDataWriter.append(equip_Make.getText()+ newline);
OutDataWriter.append(equipModel_No.getText()+ newline);
OutDataWriter.append(equip_Password.getText()+ newline);
OutDataWriter.append(equipWeb_Site.getText()+ newline);
//OutDataWriter.append(equipNotes.getText());
OutDataWriter.close();
fos.flush();
fos.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
return null;
}
}
Celui-ci construit le nom du fichier
private String BuildNewFileName()
{ // creates a new filr name
Time today = new Time(Time.getCurrentTimezone());
today.setToNow();
StringBuilder sb = new StringBuilder();
sb.append(today.year + ""); // Year)
sb.append("_");
sb.append(today.monthDay + ""); // Day of the month (1-31)
sb.append("_");
sb.append(today.month + ""); // Month (0-11))
sb.append("_");
sb.append(today.format("%k:%M:%S")); // Current time
sb.append(".txt"); //Completed file name
myNewFileName = sb.toString();
//Replace (:) with (_)
myNewFileName = myNewFileName.replaceAll(":", "_");
return myNewFileName;
}
J'espère que cela t'aides! Il m'a fallu beaucoup de temps pour le faire fonctionner.
Vous pouvez trouver ces méthodes utiles pour lire et écrire des données dans Android.
public void saveData(View view) {
String text = "This is the text in the file, this is the part of the issue of the name and also called the name od the college ";
FileOutputStream fos = null;
try {
fos = openFileOutput("FILE_NAME", MODE_PRIVATE);
fos.write(text.getBytes());
Toast.makeText(this, "Data is saved "+ getFilesDir(), Toast.LENGTH_SHORT).show();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos!= null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public void logData(View view) {
FileInputStream fis = null;
try {
fis = openFileInput("FILE_NAME");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb= new StringBuilder();
String text;
while((text = br.readLine()) != null){
sb.append(text).append("\n");
Log.e("TAG", text
);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Réponse supplémentaire
Après avoir écrit sur le stockage externe, certains gestionnaires de fichiers ne voient pas le fichier immédiatement. Cela peut être déroutant si un utilisateur pense avoir copié quelque chose sur la carte SD, mais ne le trouve pas là. Ainsi, après avoir copié le fichier, exécutez le code suivant pour informer les gestionnaires de fichiers de sa présence.
MediaScannerConnection.scanFile(
context,
new String[]{myFile.getAbsolutePath()},
null,
null);
Voir la documentation et cette réponse pour plus.
ContextWrapper contextWrapper = new ContextWrapper(getApplicationContext()); //getappcontext for just this activity context get
File file = contextWrapper.getDir(file_path, Context.MODE_PRIVATE);
if (!isExternalStorageAvailable() || isExternalStorageReadOnly())
{
saveToExternalStorage.setEnabled(false);
}
else
{
External_File = new File(getExternalFilesDir(file_path), file_name);//if ready then create a file for external
}
}
try
{
FileInputStream fis = new FileInputStream(External_File);
DataInputStream in = new DataInputStream(fis);
BufferedReader br =new BufferedReader(new InputStreamReader(in));
String strLine;
while ((strLine = br.readLine()) != null)
{
myData = myData + strLine;
}
in.close();
}
catch (IOException e)
{
e.printStackTrace();
}
InputText.setText("Save data of External file:::: "+myData);
private static boolean isExternalStorageReadOnly()
{
String extStorageState = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(extStorageState))
{
return true;
}
return false;
}
private static boolean isExternalStorageAvailable()
{
String extStorageState = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(extStorageState))
{
return true;
}
return false;
}
Même si les réponses ci-dessus sont correctes, je souhaite toutefois ajouter un avis pour distinguer les types de stockage:
- Stockage interne: il devrait être écrit 'stockage privé' car il appartient à l'application et ne peut pas être partagé. L'emplacement où il est enregistré dépend de l'emplacement d'installation de l'application. Si l'application a été installée sur une carte SD (je parle de la carte de stockage externe que vous insérez davantage dans un téléphone cellulaire pour plus d'espace pour stocker des images, des vidéos, ...), votre fichier appartiendra à l'application, ce qui signifie une carte SD. Et si l'application a été installée sur une carte interne (je parle de la carte de stockage intégrée fournie avec votre téléphone portable), votre fichier sera dans une carte interne.
- Stockage externe: il devrait être écrit 'stockage public' car il peut être partagé. Et ce mode se divise en 2 groupes: stockage externe privé et stockage externe public. Fondamentalement, ils sont presque les mêmes, vous pouvez consulter plus de ce site: https://developer.Android.com/training/data-storage/files
- Une vraie carte SD (je veux dire la carte de stockage externe que vous insérez davantage dans un téléphone cellulaire pour plus d'espace pour stocker des images, des vidéos, ...): cela n'était pas clairement indiqué sur la documentation Android, tant de personnes confondu avec comment sauvegarder des fichiers sur cette carte.
Voici le lien vers un code source pour les cas que j'ai mentionnés ci-dessus: https://github.com/mttdat/FileUtils