Zapisywanie pliku w pamięci zewnętrznej w systemie Android

Aby zapisać do pamięci zewnętrznej w urządzeniach Lollipop+ potrzebujemy:

1. Dodaj następujące uprawnienia do manifestu:

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

2. Prośba o zgodę od użytkownika:

          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!
                }
              }
   

3. Obsługa odpowiedzi użytkownika wewnątrz aktywności:

   @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();
           }
        }
    }
   

Powinieneś przeczytać dokumentację dotyczącą przechowywania rzeczy zewnętrznie na Androidzie. Istnieje wiele problemów, które mogą istnieć z obecnym kodem i myślę, że przeglądanie dokumentacji może pomóc ci je rozwikłać.

Wiem, że to trochę za późno, ale zrobiłem to w ten sposób, tworzy katalog dokumentów, a następnie podkatalog dla aplikacji i zapisuje pliki do niego.

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

Ten tworzy nazwę pliku

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

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

ODPOWIEDŹ Uzupełniająca

Po zapisaniu do pamięci zewnętrznej, niektóre menedżery plików nie widzą Pliku od razu. Może to być mylące, jeśli użytkownik uważa, że skopiował coś na kartę SD, ale nie może go tam znaleźć. Po skopiowaniu pliku uruchom poniższy kod, aby powiadomić menedżerów plików o jego obecności.

MediaScannerConnection.scanFile(
        context,
        new String[]{myFile.getAbsolutePath()},
        null,
        null);

Mimo, że powyższe odpowiedzi są poprawne, ale chcę dodać informację, aby rozróżnić rodzaje przechowywania:

• Pamięć wewnętrzna: powinna ona oznaczać "pamięć prywatna", ponieważ należy do aplikacji i nie może być współdzielona. Miejsce jego zapisania zależy od miejsca zainstalowania aplikacji. Jeśli aplikacja została zainstalowana na karcie SD (mam na myśli zewnętrzną kartę pamięci, którą wkładasz więcej do telefonu komórkowego, aby uzyskać więcej miejsca na przechowywanie obrazów, filmów,...), Twój plik będzie należał do aplikacji oznacza, że Twój plik będzie w Karta SD. A jeśli aplikacja została zainstalowana na wewnętrznej karcie (mam na myśli wbudowaną kartę pamięci dostarczaną z telefonem komórkowym), plik będzie znajdował się na wewnętrznej karcie.
• external storage : powinno być napisane "public storage", ponieważ może być współdzielone. Ten tryb dzieli się na 2 grupy: prywatną zewnętrzną pamięć masową i publiczną zewnętrzną pamięć masową. Zasadniczo są one prawie takie same, możesz skonsultować Więcej z tej strony: https://developer.android.com/training/data-storage/files
• [[4]}prawdziwa karta SD (mam na myśli zewnętrzną kartę pamięci, którą wkładasz więcej do telefonu komórkowego, aby uzyskać więcej miejsca na zdjęcia, filmy,...): nie zostało to wyraźnie stwierdzone w dokumentach Androida, więc wiele osób może być mylonych z tym, jak zapisywać pliki na tej karcie.

Oto link do kodu źródłowego przypadków, o których wspomniałem powyżej: https://github.com/mttdat/FileUtils