Android
FileIO con Android
Buscar..
Introducción
Leer y escribir archivos en Android no es diferente de leer y escribir archivos en Java estándar. Se puede usar el mismo paquete java.io Sin embargo, hay algunos aspectos específicos relacionados con las carpetas donde se le permite escribir, los permisos en general y las soluciones MTP.
Observaciones
Android proporciona medios para compartir el archivo entre varias aplicaciones como se documenta aquí . Esto no es necesario si solo hay una aplicación que crea y utiliza el archivo.
Android ofrece opciones de almacenamiento alternativas, como preferencias compartidas y privadas, paquetes guardados y base de datos incorporada. En algunos casos, son una mejor opción que usar archivos simples.
La actividad de Android tiene pocos métodos específicos que se parecen a los reemplazos de los métodos estándar de archivo IO de Java. Por ejemplo, en lugar de File.delete() puede llamar a Context.deleteFile() , y en lugar de aplicar File.listFiles() recursiva, puede llamar a Context.fileList() para obtener la lista de todos los archivos específicos de su aplicación con algo menos código. Sin embargo, no proporcionan funcionalidad adicional más allá del paquete java.io estándar.
Obtención de la carpeta de trabajo.
Puede obtener su carpeta de trabajo llamando al método getFilesDir() en su Actividad (Actividad es la clase central en su aplicación que se hereda de Context. Consulte aquí ). La lectura no es diferente. Solo su aplicación tendrá acceso a esta carpeta.
Su actividad podría contener el siguiente código, por ejemplo:
File myFolder = getFilesDir();
File myFile = new File(myFolder, "myData.bin");
Escritura de matriz en bruto de bytes
File myFile = new File(getFilesDir(), "myData.bin");
FileOutputStream out = new FileOutputStream(myFile);
// Write four bytes one two three four:
out.write(new byte [] { 1, 2, 3, 4}
out.close()
No hay nada específico de Android con este código. Si escribe muchos valores pequeños a menudo, use BufferedOutputStream para reducir el desgaste del SSD interno del dispositivo.
Serialización del objeto.
La vieja y buena serialización de objetos Java está disponible para usted en Android. Puedes definir clases serializables como:
class Cirle implements Serializable {
final int radius;
final String name;
Circle(int radius, int name) {
this.radius = radius;
this.name = name;
}
}
y luego escriba luego en ObjectOutputStream:
File myFile = new File(getFilesDir(), "myObjects.bin");
FileOutputStream out = new FileOutputStream(myFile);
ObjectOutputStream oout = new ObjectOutputStream(new BufferedOutputStream(out));
oout.writeObject(new Circle(10, "One"));
oout.writeObject(new Circle(12, "Two"));
oout.close()
La serialización de objetos Java puede ser una opción perfecta o realmente mala, dependiendo de lo que quieras hacer con ella, fuera del alcance de este tutorial y, a veces, basado en la opinión. Lea acerca del control de versiones primero si decide usarlo.
Escritura en almacenamiento externo (tarjeta SD)
También puede leer y escribir desde / a la tarjeta de memoria (tarjeta SD) que está presente en muchos dispositivos Android. Se puede acceder a los archivos en esta ubicación mediante otros programas, también directamente por el usuario después de conectar el dispositivo a la PC mediante un cable USB y habilitar el protocolo MTP.
Encontrar la ubicación de la tarjeta SD es algo más problemático. La clase de entorno contiene métodos estáticos para obtener "directorios externos" que normalmente deberían estar dentro de la tarjeta SD, también información si la tarjeta SD existe y se puede escribir. Esta pregunta contiene respuestas valiosas sobre cómo asegurarse de que se encontrará la ubicación correcta.
El acceso al almacenamiento externo requiere permisos en tu manifiesto de Android:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
Para las versiones anteriores de Android que ponen permisos, es suficiente poner estos permisos en manifiesto (el usuario debe aprobar durante la instalación). Sin embargo, a partir de Android 6.0, Android solicita la aprobación del usuario en el momento del primer acceso, y debe admitir este nuevo enfoque. De lo contrario se niega el acceso, independientemente de su manifiesto.
En Android 6.0, primero debe verificar el permiso y luego, si no se le otorga, solicitarlo. Los ejemplos de código se pueden encontrar dentro de esta pregunta SO .
Resolviendo el problema de "archivos MTP invisibles".
Si crea archivos para exportarlos a través del cable USB al escritorio mediante el protocolo MTP, es posible que los archivos recién creados no se vean inmediatamente en el explorador de archivos que se ejecuta en la computadora de escritorio conectada. Para hacer visibles los nuevos archivos, debe llamar a MediaScannerConnection :
File file = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_DOCUMENTS), "theDocument.txt");
FileOutputStream out = new FileOutputStream(file)
... (write the document)
out.close()
MediaScannerConnection.scanFile(this, new String[] {file.getPath()}, null, null);
context.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,
Uri.fromFile(file)));
Este código de llamada MediaScannerConnection funciona solo para archivos, no para directorios. El problema se describe en este informe de error de Android . Esto puede solucionarse para algunas versiones en el futuro o en algunos dispositivos.
Trabajando con archivos grandes
Los archivos pequeños se procesan en una fracción de segundo y puede leerlos / escribirlos en lugar del código donde lo necesite. Sin embargo, si el archivo es más grande o más lento de procesar, es posible que necesite usar AsyncTask en Android para trabajar con el archivo en segundo plano:
class FileOperation extends AsyncTask<String, Void, File> {
@Override
protected File doInBackground(String... params) {
try {
File file = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_DOCUMENTS), "bigAndComplexDocument.odf");
FileOutputStream out = new FileOutputStream(file)
... (write the document)
out.close()
return file;
} catch (IOException ex) {
Log.e("Unable to write", ex);
return null;
}
}
@Override
protected void onPostExecute(File result) {
// This is called when we finish
}
@Override
protected void onPreExecute() {
// This is called before we begin
}
@Override
protected void onProgressUpdate(Void... values) {
// Unlikely required for this example
}
}
}
y entonces
new FileOperation().execute("Some parameters");
Esta pregunta SO contiene el ejemplo completo sobre cómo crear y llamar a AsyncTask. También vea la pregunta sobre el manejo de errores sobre cómo manejar las excepciones de IO y otros errores.
