Android
Almacenamiento de archivos en almacenamiento interno y externo

Sintaxis

• FileOutputStream openFileInput (nombre de cadena)
• FileOutputStream openFileOutput (nombre de cadena, modo int)
• Archivo (Archivo dir, Nombre de la cadena)
• Archivo (ruta de la cadena)
• Archivo getExternalStoragePublicDirectory (tipo de cadena)
• Archivo getExternalFilesDir (tipo de cadena)

Parámetros

Uso de almacenamiento interno

De forma predeterminada, todos los archivos que guarde en Almacenamiento interno son privados para su aplicación. No se puede acceder a ellos por otras aplicaciones, ni al usuario en circunstancias normales. Estos archivos se eliminan cuando el usuario desinstala la aplicación .

Para escribir texto en un archivo

String fileName= "helloworld";
String textToWrite = "Hello, World!";
FileOutputStream fileOutputStream;

try {
  fileOutputStream = openFileOutput(fileName, Context.MODE_PRIVATE);
  fileOutputStream.write(textToWrite.getBytes());
  fileOutputStream.close();
} catch (Exception e) {
  e.printStackTrace();
}

Para agregar texto a un archivo existente

Use Context.MODE_APPEND para el parámetro de modo de openFileOutput

fileOutputStream = openFileOutput(fileName, Context.MODE_APPEND);

Uso de almacenamiento externo

El almacenamiento "externo" es otro tipo de almacenamiento que podemos usar para guardar archivos en el dispositivo del usuario. Tiene algunas diferencias clave con respecto al almacenamiento "interno", a saber:

• No siempre está disponible. En el caso de un medio extraíble (tarjeta SD), el usuario simplemente puede quitar el almacenamiento.
• No es privado. El usuario (y otras aplicaciones) tienen acceso a estos archivos.
• Si el usuario desinstala la aplicación, los archivos que guarde en el directorio recuperado con getExternalFilesDir() se eliminarán.

Para usar almacenamiento externo, primero debemos obtener los permisos adecuados. Necesitará usar:

• android.permission.WRITE_EXTERNAL_STORAGE para leer y escribir
• android.permission.READ_EXTERNAL_STORAGE para solo leer

Para otorgar estos permisos, deberá identificarlos en su AndroidManifest.xml como tal

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

NOTA: ya que son permisos peligrosos si está utilizando el nivel de API 23 o superior, deberá solicitar los permisos en tiempo de ejecución .

Antes de intentar escribir o leer desde el almacenamiento externo, siempre debe verificar que el medio de almacenamiento esté disponible.

String state = Environment.getExternalStorageState();
if (state.equals(Environment.MEDIA_MOUNTED)) {
    // Available to read and write
}
if (state.equals(Environment.MEDIA_MOUNTED) || 
        state.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
    // Available to at least read
}

Al escribir archivos en el almacenamiento externo, debe decidir si el archivo debe ser reconocido como Público o Privado. Si bien ambos tipos de archivos aún son accesibles para el usuario y otras aplicaciones en el dispositivo, existe una distinción clave entre ellos.

Los archivos públicos deben permanecer en el dispositivo cuando el usuario desinstala la aplicación. Un ejemplo de un archivo que debe guardarse como Público sería fotos tomadas a través de su aplicación.

Todos los archivos privados deben eliminarse cuando el usuario desinstala la aplicación. Estos tipos de archivos serían específicos de la aplicación y no serían de utilidad para el usuario u otras aplicaciones. Ex. Archivos temporales descargados / utilizados por su aplicación.

A continuación, se explica cómo obtener acceso al directorio Documents para archivos públicos y privados.

Público

// Access your app's directory in the device's Public documents directory
File docs = new File(Environment.getExternalStoragePublicDirectory(
        Environment.DIRECTORY_DOCUMENTS), "YourAppDirectory");
// Make the directory if it does not yet exist
myDocs.mkdirs();

Privado

// Access your app's Private documents directory
File file = new File(context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS), 
        "YourAppDirectory");
// Make the directory if it does not yet exist
myDocs.mkdirs();

Android: Almacenamiento interno y externo - Aclaración de terminología

Los desarrolladores de Android (principalmente principiantes) se han confundido con la terminología de almacenamiento interno y externo. Hay muchas preguntas sobre Stackoverflow sobre el mismo. Esto se debe principalmente al hecho de que la terminología de acuerdo con la documentación de Google / oficial de Android es bastante diferente a la de un usuario normal del sistema operativo Android. Por lo tanto, pensé que documentar esto ayudaría.

Lo que pensamos - Terminología del usuario (UT)

Pero, de acuerdo con la documentación / guía de Android - Terminología de Google (GT)

Almacenamiento interno (GT):

De forma predeterminada, los archivos guardados en el almacenamiento interno son privados para su aplicación y otras aplicaciones no pueden acceder a ellos (ni puede hacerlo el usuario).

Almacenamiento externo (GT):

Puede ser un medio de almacenamiento extraíble (como una tarjeta SD) o un almacenamiento interno (no extraíble).

El almacenamiento externo (GT) se puede clasificar en dos tipos:

En una palabra,

Almacenamiento externo (GT) = Almacenamiento interno (UT) y Almacenamiento externo (UT)

Almacenamiento extraíble (GT) = Almacenamiento externo (UT)

Almacenamiento interno (GT) no tiene un término en UT.

Déjame explicarte claramente,

Almacenamiento interno (GT): de forma predeterminada, los archivos guardados en el almacenamiento interno son privados para su aplicación y otras aplicaciones no pueden acceder a ellos. El usuario de la aplicación tampoco puede acceder a ellos mediante el administrador de archivos; Incluso después de habilitar la opción "Mostrar archivos ocultos" en el administrador de archivos. Para acceder a los archivos en el almacenamiento interno (GT), debe rootear su teléfono Android. Además, cuando el usuario desinstala su aplicación, estos archivos se eliminan / eliminan.

Por lo tanto, el almacenamiento interno (GT) NO es lo que pensamos como la memoria interna de 32/64 GB de Nexus 6P

En general, la ubicación del almacenamiento interno (GT) sería: /data/data/your.application.package.appname/someDirectory/

Almacenamiento externo (GT):

Todos los dispositivos compatibles con Android admiten un "almacenamiento externo" compartido que puede usar para guardar archivos. Los archivos guardados en el almacenamiento externo son legibles en todo el mundo y pueden ser modificados por el usuario cuando permiten que el almacenamiento masivo USB transfiera archivos a una computadora.

Ubicación de almacenamiento externo (GT): podría estar en cualquier lugar en su almacenamiento interno (UT) o en su almacenamiento extraíble (GT), es decir, en una tarjeta micro SD. Depende del OEM de su teléfono y también de la versión del sistema operativo Android.

Para leer o escribir archivos en el almacenamiento externo (GT), su aplicación debe adquirir los permisos del sistema READ_EXTERNAL_STORAGE o WRITE_EXTERNAL_STORAGE .

Por ejemplo:

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

Si necesita leer y escribir archivos, debe solicitar solo el permiso WRITE_EXTERNAL_STORAGE , ya que implícitamente también requiere acceso de lectura.

En Almacenamiento externo (GT) , también puede guardar archivos privados de la aplicación.

Pero,

Cuando el usuario desinstala su aplicación, este directorio y todo su contenido se eliminan.

¿Cuándo necesita guardar los archivos que son privados de la aplicación en el almacenamiento externo (GT) ?

Si está manejando archivos que no están destinados a otras aplicaciones (como texturas gráficas o efectos de sonido utilizados solo por su aplicación), debe usar un directorio de almacenamiento privado en el almacenamiento externo

A partir de Android 4.4, leer o escribir archivos en los directorios privados de su aplicación no requiere los READ_EXTERNAL_STORAGE o WRITE_EXTERNAL_STORAGE . Por lo tanto, puede declarar que el permiso debe solicitarse solo en las versiones inferiores de Android agregando el atributo maxSdkVersion :

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

Métodos para almacenar en almacenamiento interno (GT):

Ambos métodos están presentes en la clase de contexto

File getDir (String name, int mode)

File getFilesDir () 

Métodos para almacenar en almacenamiento externo primario, es decir, almacenamiento interno (UT):

File getExternalStorageDirectory ()

File getExternalFilesDir (String type)

File getExternalStoragePublicDirectory (String type)

Al principio, todos usaban Environment.getExternalStorageDirectory () , que apuntaba a la raíz del almacenamiento externo primario . Como resultado, el almacenamiento externo primario se llenó con contenido aleatorio.

Posteriormente, se agregaron estos dos métodos:

1. En la clase de Context , agregaron getExternalFilesDir () , apuntando a un directorio específico de la aplicación en el almacenamiento externo primario. Este directorio y su contenido se eliminarán cuando la aplicación se desinstale.

2. Environment.getExternalStoragePublicDirectory () para lugares centralizados para almacenar tipos de archivos conocidos, como fotos y películas. Este directorio y su contenido NO se eliminarán cuando la aplicación se desinstale.

Métodos para almacenar en almacenamiento extraíble (GT), es decir, tarjeta micro SD

Antes del nivel de API 19 , no había forma oficial de almacenar en la tarjeta SD. Pero, muchos podrían hacerlo utilizando bibliotecas o API no oficiales.

Oficialmente, se introdujo un método en la clase de Context en el nivel de API 19 (versión 4.4 de Android - Kitkat).

File[] getExternalFilesDirs (String type)

Devuelve las rutas absolutas a los directorios específicos de la aplicación en todos los dispositivos de almacenamiento compartidos / externos donde la aplicación puede colocar los archivos persistentes que posee. Estos archivos son internos a la aplicación y no suelen ser visibles para el usuario como medio.

Eso significa que devolverá las rutas a ambos tipos de almacenamiento externo (GT): memoria interna y tarjeta Micro SD. En general, la segunda ruta sería la ruta de almacenamiento de la tarjeta micro SD (pero no siempre). Así que necesitas comprobarlo ejecutando el código con este método.

Ejemplo con fragmento de código:

Creé un nuevo proyecto de Android con actividad vacía, escribí el siguiente código dentro de

protected void onCreate(Bundle savedInstanceState) método de MainActivity.java

    File internal_m1 = getDir("custom", 0);
    File internal_m2 = getFilesDir();

    File external_m1 =  Environment.getExternalStorageDirectory();
    
    File external_m2 =  getExternalFilesDir(null);
    File external_m2_Args = getExternalFilesDir(Environment.DIRECTORY_PICTURES);

    File external_m3 = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
    
    File[] external_AND_removable_storage_m1 = getExternalFilesDirs(null);
    File[] external_AND_removable_storage_m1_Args = getExternalFilesDirs(Environment.DIRECTORY_PICTURES);

Después de ejecutar el código anterior,

Salida:

internal_m1: /data/data/your.application.package.appname/app_custom

internal_m2: /data/data/your.application.package.appname/files

external_m1: /storage/emulated/0

external_m2: /storage/emulated/0/Android/data/your.application.package.appname/files

external_m2_Args: /storage/emulated/0/Android/data/your.application.package.appname/files/Pictures

external_m3: /storage/emulated/0/Pictures

external_AND_removable_storage_m1 (first path):
/storage/emulated/0/Android/data/your.application.package.appname/files

external_AND_removable_storage_m1 (second path):    
/storage/sdcard1/Android/data/your.application.package.appname/files

 external_AND_removable_storage_m1_Args (first path):
/storage/emulated/0/Android/data/your.application.package.appname/files/Pictures

external_AND_removable_storage_m1_Args (second path): /storage/sdcard1/Android/data/your.application.package.appname/files/Pictures

Nota: He conectado mi teléfono a la PC con Windows; habilitó ambas opciones de desarrollador, depuración USB y luego ejecutó este código. Si no conectas tu teléfono ; pero en lugar de ejecutar esto en el emulador de Android , su salida puede variar. Mi modelo de teléfono es Coolpad Note 3, se ejecuta en Android 5.1

Ubicaciones de almacenamiento en mi teléfono:

Ubicación de almacenamiento Micro SD : /storage/sdcard1

Ubicación del almacenamiento interno (UT) : /storage/sdcard0 .

Tenga en cuenta que /sdcard & /storage/emulated/0 también apunta al almacenamiento interno (UT). Pero estos son enlaces simbólicos a /storage/sdcard0 .

Para entender claramente las diferentes rutas de almacenamiento en Android, por favor, vaya a través de esta respuesta

Descargo de responsabilidad: todas las rutas de almacenamiento mencionadas anteriormente son rutas en mi teléfono. Es posible que sus archivos no se almacenen en las mismas rutas de almacenamiento. Debido a que las ubicaciones / rutas de almacenamiento pueden variar en otros teléfonos móviles dependiendo de su proveedor, fabricante y diferentes versiones del sistema operativo Android.

Guardar base de datos en la tarjeta SD (Copia de seguridad de base de datos en SD)

    public static Boolean ExportDB(String DATABASE_NAME , String packageName , String folderName){
    //DATABASE_NAME including ".db" at the end like "mayApp.db"
    String DBName = DATABASE_NAME.substring(0, DATABASE_NAME.length() - 3);
    File data = Environment.getDataDirectory();
    FileChannel source=null;
    FileChannel destination=null;
    String currentDBPath = "/data/"+ packageName +"/databases/"+DATABASE_NAME; // getting app db path

    File sd = Environment.getExternalStorageDirectory(); // getting phone SD card path
    String backupPath = sd.getAbsolutePath() + folderName; // if you want to set backup in specific folder name
        /* be careful , foldername must initial like this : "/myFolder" . dont forget "/" at begin of folder name
            you could define foldername like this : "/myOutterFolder/MyInnerFolder" and so on ...
        */
    File dir = new File(backupPath);
    if(!dir.exists()) // if there was no folder at this path , it create it .
    {
        dir.mkdirs();
    }

    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss");
    Date date = new Date();
        /* use date including file name for arrange them and preventing to make file with the same*/
    File currentDB = new File(data, currentDBPath);
    File backupDB = new File(backupPath, DBName +"("+ dateFormat.format(date)+").db");
    try {
        if (currentDB.exists() && !backupDB.exists()) {
            source = new FileInputStream(currentDB).getChannel();
            destination = new FileOutputStream(backupDB).getChannel();
            destination.transferFrom(source, 0, source.size());
            source.close();
            destination.close();
            return true;
        }
        return false;
    } catch(IOException e) {
        e.printStackTrace();
        return false;
    }
}

llame a este método de esta manera:

ExportDB ("myDB.db", "com.example.exam", "/ myFolder");

Fetch Directorio de dispositivos:

Primero agregue el permiso de almacenamiento para leer / buscar el directorio del dispositivo.

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

Crear clase de modelo

//create one directory model class
//to store directory title and type in list

public class DirectoryModel {
    String dirName;
    int dirType; // set 1 or 0, where 0 for directory and 1 for file.

    public int getDirType() {
        return dirType;
    }

    public void setDirType(int dirType) {
        this.dirType = dirType;
    }

    public String getDirName() {
        return dirName;
    }

    public void setDirName(String dirName) {
        this.dirName = dirName;
    }
}

Crear lista utilizando el modelo de directorio para agregar datos de directorio.

//define list to show directory

List<DirectoryModel> rootDir = new ArrayList<>();

Fetch directorio utilizando el siguiente método.

//to fetch device directory

private void getDirectory(String currDir) { // pass device root directory
        File f = new File(currDir);
        File[] files = f.listFiles();
        if (files != null) {
            if (files.length > 0) {
                rootDir.clear();
                for (File inFile : files) {
                    if (inFile.isDirectory()) { //return true if it's directory
                        // is directory
                        DirectoryModel dir = new DirectoryModel();
                        dir.setDirName(inFile.toString().replace("/storage/emulated/0", ""));
                        dir.setDirType(0); // set 0 for directory
                        rootDir.add(dir);
                    } else if (inFile.isFile()) { // return true if it's file
                        //is file
                        DirectoryModel dir = new DirectoryModel();
                        dir.setDirName(inFile.toString().replace("/storage/emulated/0", ""));
                        dir.setDirType(1); // set 1 for file
                        rootDir.add(dir);
                    }
                }
            }
            printDirectoryList();
        }
    }

Imprimir lista de directorios en el registro.

//print directory list in logs

private void printDirectoryList() {
    for (int i = 0; i < rootDir.size(); i++) {
        Log.e(TAG, "printDirectoryLogs: " + rootDir.get(i).toString());
    }
}

Uso

//to Fetch Directory Call function with root directory.

String rootPath = Environment.getExternalStorageDirectory().toString(); // return ==>  /storage/emulated/0/
getDirectory(rootPath );

Para recuperar archivos / carpetas internos de un directorio específico, use el mismo método, solo cambie el argumento, pase la ruta actual seleccionada en el argumento y maneje la respuesta para el mismo.

Para obtener la extensión de archivo:

private String getExtension(String filename) {

    String filenameArray[] = filename.split("\\.");
    String extension = filenameArray[filenameArray.length - 1];
    Log.d(TAG, "getExtension: " + extension);

    return extension;
}