Cómo crear un directorio específico de la aplicación (Android KITKAT 4.4+) en el almacenamiento externo secundario (tarjeta SD externa) Desarrollador de registros, desarrollo de aplicaciones

Este código solo debe usarse para escribir en el almacenamiento secundario en dispositivos Android 4.4+ si todo lo demás falla. Recomiendo encarecidamente que NUNCA confíes en este código. Este código NO utiliza acceso de root.

La clase :

Código:
———————————————————————————-
/ *
* Copyright (C) 2014 NextApp, Inc.
* *
* Licenciado bajo la Licencia Apache, Versión 2.0 (la “Licencia”); no puede usar este archivo excepto en cumplimiento con la Licencia.
* Puede obtener una copia de la Licencia en
* *
* Página en apache.org
* *
* A menos que lo exija la ley aplicable o se acuerde por escrito, el software distribuido bajo la Licencia se distribuye “TAL CUAL”
* BASE, SIN GARANTÍAS O CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita. Ver la licencia para el idioma específico
* permisos y limitaciones que rigen bajo la Licencia.
* /

paquete nextapp.mediafile;

import java.io: entusiasta de java y código abierto? .File;
import java.io: entusiasta de java y código abierto? .IOException;
import java.io: entusiasta de java y código abierto? .OutputStream;

importar android.content.ContentResolver;
importar android.content.ContentValues;
importar Android Forum.Uri;
importar android.provider.MediaStore;

/ **
* Contenedor para manipular archivos a través del proveedor de contenido multimedia de Android. A partir de Android 4.4 KitKat, las aplicaciones ya no pueden escribir
* al “almacenamiento secundario” de un dispositivo. Escribir operaciones con java.io, entusiasta de Java y código abierto. La API de archivos fallará. Esta clase restaura el acceso a
* esas operaciones de escritura a través del proveedor de contenido multimedia.
* *
* Tenga en cuenta que esta clase se basa en las características operativas internas de la API del proveedor de contenido multimedia y, como tal, no
* garantizado para el futuro. Por otra parte, todos pensamos que el java.io, ¿entusiasta de Java y de código abierto? La API de archivo iba a ser a prueba de futuro para la tarjeta de medios
* acceso, por lo que todas las apuestas están desactivadas.
* *
* Si se ve obligado a usar esta clase, es porque Google / AOSP tomó una decisión API muy pobre en Android 4.4 KitKat.
* Lea más en KitKat hará que su tarjeta SD sea completamente inútil: según la API de Android …
* *
* Su aplicación debe declarar el permiso “android.permission.WRITE_EXTERNAL_STORAGE”.
* /
MediaFile de clase pública {

archivo de archivo final privado;
contenido final privado ContentResolver contentResolver;
archivos Uri finales privadosUri;
imágenes finales privadas de UriUri;

Public MediaFile (ContentResolver contentResolver, File file) {
this.file = archivo;
this.contentResolver = contentResolver;
filesUri = MediaStore.Files.getContentUri (“externo”);
imagesUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
}

/ **
* Borra el archivo. Devuelve verdadero si el archivo se ha eliminado correctamente o si no existe. Esta operación no es
* recursivo.
* /
público booleano delete ()
lanza IOException {
if (! file.exists ()) {
volver verdadero;
}

directorio booleano = file.isDirectory ();
if (directorio) {
// Verifique que el directorio no contenga ningún archivo / directorio dentro de él.
Cadena [] archivos = file.list ();
if (files! = null && files.length> 0) {
falso retorno;
}
}

Cadena donde = MediaStore.MediaColumns.DATA + “=?”;
String [] selectionArgs = new String [] {file.getAbsolutePath ()};

// Eliminar la entrada de la base de datos de medios. Esto realmente eliminará los archivos multimedia (imágenes, audio y video).
contentResolver.delete (filesUri, where, selectionArgs);

if (file.exists ()) {
// Si el archivo no es un archivo multimedia, cree una nueva entrada que sugiera que esta ubicación es una imagen, incluso
// aunque no lo es.
Valores de ContentValues = new ContentValues ();
values.put (MediaStore.Files.FileColumns.DATA, file.getAbsolutePath ());
contentResolver.insert (imagesUri, valores);

// Eliminar la entrada creada, de modo que el proveedor de contenido eliminará el archivo.
contentResolver.delete (filesUri, where, selectionArgs);
}

return! file.exists ();
}

Archivo público getFile () {
archivo de retorno;
}

/ **
* Crea un nuevo directorio. Devuelve verdadero si el directorio se creó con éxito o existe.
* /
public boolean mkdir ()
lanza IOException {
if (file.exists ()) {
return file.isDirectory ();
}

Valores de ContentValues;
Uri uri;

// Cree una entrada de base de datos de medios para el directorio. Este paso en realidad no hará que se cree el directorio.
valores = nuevos ContentValues ();
values.put (MediaStore.Files.FileColumns.DATA, file.getAbsolutePath ());
contentResolver.insert (filesUri, valores);

// Cree una entrada para un archivo de imagen temporal dentro del directorio creado.
// Este paso en realidad provoca la creación del directorio.
valores = nuevos ContentValues ();
values.put (MediaStore.Files.FileColumns.DATA, file.getAbsolutePath () + “/temp.jpg”);
uri = contentResolver.insert (imagesUri, valores);

// Eliminar la entrada temporal.
contentResolver.delete (uri, nulo, nulo);

return file.exists ();
}

/ **
* Devuelve un OutputStream para escribir en el archivo. El archivo se truncará de inmediato.
* /
Public OutputStream write ()
lanza IOException {
if (file.exists () && file.isDirectory ()) {
lanzar una nueva IOException (“El archivo existe y es un directorio”);
}

// Eliminar cualquier entrada existente de la base de datos de medios.
// Esto también puede eliminar el archivo (para tipos de medios), pero eso es irrelevante, ya que se truncará momentáneamente en cualquier caso.
Cadena donde = MediaStore.MediaColumns.DATA + “=?”;
String [] selectionArgs = new String [] {file.getAbsolutePath ()};
contentResolver.delete (filesUri, where, selectionArgs);

Valores de ContentValues = new ContentValues ();
values.put (MediaStore.Files.FileColumns.DATA, file.getAbsolutePath ());
Uri uri = contentResolver.insert (filesUri, valores);

if (uri == nulo) {
// No debería ocurrir.
lanzar una nueva IOException (“Error interno”);
}

return contentResolver.openOutputStream (uri);
}
}

Descarga de la fuente (o corte / pegue lo anterior): http://android.nextapp.com/conte…
Proyecto Eclipse con aplicación de prueba: http://android.nextapp.com/conte…
APK de la aplicación de prueba: http://android.nextapp.com/conte…

Espero que la respuesta dada sea una ayuda completa para ti …

Gracias A2A …