Introducción a esta sección:
Después de estudiar la sección anterior, creo que ya sabes cómo usar el ContentProvider proporcionado por el sistema o un ContentProvider personalizado, lo cual básicamente satisface las necesidades del desarrollo diario. Curiosamente, en la documentación oficial vi estos otros Providers:
Calendar Provider: Calendar Provider, es una biblioteca de recursos para eventos relacionados con el calendario. A través de su API, podemos realizar operaciones de agregar, eliminar, modificar y consultar en calendarios, horas, reuniones, recordatorios, etc.
Contacts Provider: Contact Provider, no hace falta decirlo, es el más utilizado ~ Si tengo tiempo más adelante, volveré a traducir este artículo.
Storage Access Framework(SAF): Storage Access Framework, una nueva característica introducida después de 4.4, que facilita a los usuarios navegar por el contenido de almacenamiento en el teléfono. El contenido accesible incluye no solo documentos, imágenes, videos, audio y descargas, sino también todo el contenido proporcionado por ciertos ContentProviders (que deben tener la API acordada). No importa de dónde provenga este contenido, ni qué aplicación invoque el comando para explorar el contenido del sistema de archivos, el sistema siempre mostrará una interfaz unificada para navegar.
En realidad, es una aplicación integrada llamada DocumentsUI. Como su IntentFilter no incluye LAUNCHER, no la encontramos en el escritorio. Jeje, prueba el siguiente código. Aquí elegimos dos teléfonos para comparar: el Lenovo S898T con 4.2 y el Nexus 5 con 5.0.1. Ejecuta el siguiente código:
Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
intent.addCategory(Intent.CATEGORY_OPENABLE);
intent.setType("image/*");
startActivity(intent);
A continuación se muestra el resultado de ejecución:

El de la derecha es la novedad que nos trajo 4.4. Generalmente podemos usarlo al obtener la URL de un archivo. A continuación, veamos brevemente el documento.
2. Un vistazo rápido al documento:
1) Componentes del marco SAF:
- Document provider: Un ContentProvider especial que permite a un servicio de almacenamiento (como Google Drive) mostrar externamente los archivos que gestiona. EsDocumentsProvider: una subclase de ContentProvider. Además, el formato de almacenamiento de document-provider es consistente con el formato tradicional de almacenamiento de archivos. En cuanto a cómo almacenar tu contenido, depende completamente de ti. El sistema Android ya ha incorporado varios Document providers de este tipo, como los Document providers de descargas, imágenes y videos.
- Client app: Una aplicación cliente normal, que al activarACTION_OPEN_DOCUMENTy/oACTION_CREATE_DOCUMENTpuede recibir el contenido devuelto por el Document provider, por ejemplo, seleccionar una imagen y luego devolver un Uri.
- Picker: Una interfaz similar a un administrador de archivos, y además a nivel de sistema, que proporciona un canal para acceder al contenido de los Document providers que cumplen las condiciones de filtrado del cliente. ¡Es el programa DocumentsUI del que hablamos!
Algunas características:
- Los usuarios pueden navegar por todo el contenido proporcionado por todos los document providers, no solo por una única aplicación.
- Proporciona la capacidad de acceso a largo plazo y continuo a los archivos en el document provider, así como la persistencia de datos. Los usuarios pueden agregar, eliminar, editar y guardar el contenido mantenido por el document provider.
- Admite múltiples usuarios y servicios de contenido temporales, por ejemplo, los proveedores de almacenamiento USB solo aparecen cuando el controlador se instala correctamente.
2) Resumen:
El núcleo de SAF es una subclase de DocumentsProvider, que sigue siendo un ContentProvider. Un document provider se organiza en un árbol de directorios de archivos tradicional:

3) Diagrama de flujo:
Como se mencionó anteriormente, los datos de document provider se basan en la jerarquía de archivos tradicional, pero eso es solo la forma de presentación externa. Cómo almacenar tus datos depende de ti, siempre que tu interfaz externa pueda ser accesible a través de la API de DocumentsProvider. El siguiente diagrama de flujo muestra una posible estructura de una aplicación de fotos usando SAF:

Análisis:
En la figura anterior, podemos ver que el Picker es un puente entre el llamador y los proveedores de contenido. Proporciona y le dice al llamador qué proveedores de contenido puede elegir, como DriveDocProvider, UsbDocProvider y CloundDocProvider.
Cuando el cliente activaACTION_OPEN_DOCUMENToACTION_CREATE_DOCUMENTel Intent, se produce la interacción anterior. Por supuesto, también podemos agregar condiciones de filtro en el Intent, por ejemplo, restringir el tipo MIME a `image`.

Son estas cosas de arriba. Si también tienes instalado otro software de visualización de imágenes, también lo verás aquí. En pocas palabras: después de que el cliente envía un Intent con las dos Actions mencionadas, se abre la interfaz de usuario del Picker, donde se muestran los Document Providers disponibles relevantes para que el usuario elija. Después de que el usuario elige, puede obtener la información relevante del archivo.
4) Llamada del cliente y obtención del Uri devuelto
El código de implementación es el siguiente:
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private static final int READ_REQUEST_CODE = 42;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btn_show = (Button) findViewById(R.id.btn_show);
btn_show.setOnClickListener(this);
}
@Override
public void onClick(View v) {
Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
intent.addCategory(Intent.CATEGORY_OPENABLE);
intent.setType("image/*");
startActivityForResult(intent, READ_REQUEST_CODE);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == READ_REQUEST_CODE && resultCode == Activity.RESULT_OK) {
Uri uri;
if (data != null) {
uri = data.getData();
Log.e("HeHe", "Uri: " + uri.toString());
}
}
}
}
Resultado de ejecución:Por ejemplo, si seleccionamos al perro, la interfaz del Picker se cerrará automáticamente y luego podemos ver en Logcat un uri como este:

5) Obtener parámetros del archivo según el uri
El código principal es el siguiente:
public void dumpImageMetaData(Uri uri) {
Cursor cursor = getContentResolver()
.query(uri, null, null, null, null, null);
try {
if (cursor != null && cursor.moveToFirst()) {
String displayName = cursor.getString(
cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
Log.e("HeHe", "Display Name: " + displayName);
int sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
String size = null;
if (!cursor.isNull(sizeIndex)) {
size = cursor.getString(sizeIndex);
}else {
size = "Unknown";
}
Log.e("HeHe", "Size: " + size);
}
}finally {
cursor.close();
}
}
Resultado de ejecución:Sigue siendo el perro. Después de llamar al método, se mostrará el nombre del archivo y el tamaño del archivo, en bytes.

6) Obtener Bitmap según el Uri
El código principal es el siguiente:
private Bitmap getBitmapFromUri(Uri uri) throws IOException {
ParcelFileDescriptor parcelFileDescriptor =
getContentResolver().openFileDescriptor(uri, "r");
FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
Bitmap image = BitmapFactory.decodeFileDescriptor(fileDescriptor);
parcelFileDescriptor.close();
return image;
}
Resultado de ejecución:

7) Obtener flujo de entrada según el Uri
El código principal es el siguiente:
private String readTextFromUri(Uri uri) throws IOException {
InputStream inputStream = getContentResolver().openInputStream(uri);
BufferedReader reader = new BufferedReader(new InputStreamReader(
inputStream));
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
stringBuilder.append(line);
}
fileInputStream.close();
parcelFileDescriptor.close();
return stringBuilder.toString();
}
El contenido anterior solo te dice qué puedes saber a través de un Uri, ¡y la obtención del Uri se logra a través de SAF!
8) Crear nuevos archivos y eliminar archivos:
Crear archivo:
private void createFile(String mimeType, String fileName) {
Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
intent.addCategory(Intent.CATEGORY_OPENABLE);
intent.setType(mimeType);
intent.putExtra(Intent.EXTRA_TITLE, fileName);
startActivityForResult(intent, WRITE_REQUEST_CODE);
}
Puedes obtener el uri del archivo creado en `onActivityResult()`.
Eliminar archivo:
La premisa es que `Document.COLUMN_FLAGS` contengaSUPPORTS_DELETE
DocumentsContract.deleteDocument(getContentResolver(), uri);
9) Escribir un Document Provider personalizado
Si deseas que los datos de tu propia aplicación también se puedan abrir en DocumentsUI, necesitas escribir tu propio document provider. A continuación se presentan los pasos para personalizar DocumentsProvider:
- La versión de API debe ser 19 o superior.
- Registra el Provider en manifest.xml.
- El nombre del Provider es el nombre de la clase más el nombre del paquete, por ejemplo:com.example.android.storageprovider.MyCloudProvider
- Authority es el nombre del paquete + el nombre del tipo de provider, por ejemplo:com.example.android.storageprovider.documents
- El valor del atributo `android:exported` es `true`.
A continuación se muestra un ejemplo de cómo escribir un Provider:
<manifest... >
...
<uses-sdk
android:minSdkVersion="19"
android:targetSdkVersion="19" />
....
<provider
android:name="com.example.android.storageprovider.MyCloudProvider"
android:authorities="com.example.android.storageprovider.documents"
android:grantUriPermissions="true"
android:exported="true"
android:permission="android.permission.MANAGE_DOCUMENTS"
android:enabled="@bool/atLeastKitKat">
<intent-filter>
<action android:name="android.content.action.DOCUMENTS_PROVIDER" />
</intent-filter>
</provider>
</application>
</manifest>
10) Subclases de DocumentsProvider
Debes implementar al menos los siguientes métodos:
- queryRoots()
- queryChildDocuments()
- queryDocument()
- openDocument()
Hay otros métodos, pero no son obligatorios. A continuación se muestra un esquema aproximado de cómo escribir un DocumentsProvider que implementa el acceso al sistema de archivos.
Implement queryRoots
@Override
public Cursor queryRoots(String[] projection) throws FileNotFoundException {
// Create a cursor with either the requested fields, or the default
// projection if "projection" is null.
final MatrixCursor result =
new MatrixCursor(resolveRootProjection(projection));
// If user is not logged in, return an empty root cursor. This removes our
// provider from the list entirely.
if (!isUserLoggedIn()) {
return result;
}
// It's possible to have multiple roots (e.g. for multiple accounts in the
// same app) -- just add multiple cursor rows.
// Construct one row for a root called "MyCloud".
final MatrixCursor.RowBuilder row = result.newRow();
row.add(Root.COLUMN_ROOT_ID, ROOT);
row.add(Root.COLUMN_SUMMARY, getContext().getString(R.string.root_summary));
// FLAG_SUPPORTS_CREATE means at least one directory under the root supports
// creating documents. FLAG_SUPPORTS_RECENTS means your application's most
// recently used documents will show up in the "Recents" category.
// FLAG_SUPPORTS_SEARCH allows users to search all documents the application
// shares.
row.add(Root.COLUMN_FLAGS, Root.FLAG_SUPPORTS_CREATE |
Root.FLAG_SUPPORTS_RECENTS |
Root.FLAG_SUPPORTS_SEARCH);
// COLUMN_TITLE is the root title (e.g. Gallery, Drive).
row.add(Root.COLUMN_TITLE, getContext().getString(R.string.title));
// This document id cannot change once it's shared.
row.add(Root.COLUMN_DOCUMENT_ID, getDocIdForFile(mBaseDir));
// The child MIME types are used to filter the roots and only present to the
// user roots that contain the desired type somewhere in their file hierarchy.
row.add(Root.COLUMN_MIME_TYPES, getChildMimeTypes(mBaseDir));
row.add(Root.COLUMN_AVAILABLE_BYTES, mBaseDir.getFreeSpace());
row.add(Root.COLUMN_ICON, R.drawable.ic_launcher);
return result;
}
Implement queryChildDocuments
public Cursor queryChildDocuments(String parentDocumentId, String[] projection,
String sortOrder) throws FileNotFoundException {
final MatrixCursor result = new
MatrixCursor(resolveDocumentProjection(projection));
final File parent = getFileForDocId(parentDocumentId);
for (File file : parent.listFiles()) {
// Adds the file's display name, MIME type, size, and so on.
includeFile(result, null, file);
}
return result;
}
Implement queryDocument
@Override
public Cursor queryDocument(String documentId, String[] projection) throws
FileNotFoundException {
// Create a cursor with the requested projection, or the default projection.
final MatrixCursor result = new
MatrixCursor(resolveDocumentProjection(projection));
includeFile(result, documentId, null);
return result;
}
Bien, eso es más o menos todo el contenido del documento. Al principio pensé en traducirlo yo mismo, pero luego encontré una traducción al chino de este documento en el sitio web '泡在网上的日子', así que fui perezoso.
Enlace a la traducción al chino:Marco de acceso al almacenamiento de Android - Storage Access Framework
3. Problema de obtención de la ruta de recursos en Android 4.4:
En realidad, el lugar donde más usamos este SAF es simplemente para obtener el Uri de una imagen. Y a partir de los ejemplos anteriores también descubrimos que el enlace que obtenemos de esta manera es así:
content://com.android.providers.media.documents/document/image%3A69983
Con este tipo de enlace, podemos obtener el uri directamente mediante los métodos anteriores.
Por supuesto, esto es para la versión 4.4 o superior.
Si es una versión anterior, el uri podría ser así:
content://media/external/images/media/image%3A69983
Aquí comparto una solución integral que vi en otro lugar. Enlace original:Problema de obtención de la ruta de recursos en Android4.4
public static String getPath(final Context context, final Uri uri) {
final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
// DocumentProvider
if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
// ExternalStorageProvider
if (isExternalStorageDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split(":");
final String type = split[0];
if ("primary".equalsIgnoreCase(type)) {
return Environment.getExternalStorageDirectory() + "/" + split[1];
}
// TODO handle non-primary volumes
}
// DownloadsProvider
else if (isDownloadsDocument(uri)) {
final String id = DocumentsContract.getDocumentId(uri);
final Uri contentUri = ContentUris.withAppendedId(
Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
return getDataColumn(context, contentUri, null, null);
}
// MediaProvider
else if (isMediaDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split(":");
final String type = split[0];
Uri contentUri = null;
if ("image".equals(type)) {
contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
} else if ("video".equals(type)) {
contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
} else if ("audio".equals(type)) {
contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
}
final String selection = "_id=?";
final String[] selectionArgs = new String[] {
split[1]
};
return getDataColumn(context, contentUri, selection, selectionArgs);
}
}
// MediaStore (and general)
else if ("content".equalsIgnoreCase(uri.getScheme())) {
return getDataColumn(context, uri, null, null);
}
// File
else if ("file".equalsIgnoreCase(uri.getScheme())) {
return uri.getPath();
}
return null;
}
/**
* Get the value of the data column for this Uri. This is useful for
* MediaStore Uris, and other file-based ContentProviders.
*
* @param context The context.
* @param uri The Uri to query.
* @param selection (Optional) Filter used in the query.
* @param selectionArgs (Optional) Selection arguments used in the query.
* @return The value of the _data column, which is typically a file path.
*/
public static String getDataColumn(Context context, Uri uri, String selection,
String[] selectionArgs) {
Cursor cursor = null;
final String column = "_data";
final String[] projection = {
column
};
try {
cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
null);
if (cursor != null && cursor.moveToFirst()) {
final int column_index = cursor.getColumnIndexOrThrow(column);
return cursor.getString(column_index);
}
} finally {
if (cursor != null)
cursor.close();
}
return null;
}
/**
* @param uri The Uri to check.
* @return Whether the Uri authority is ExternalStorageProvider.
*/
public static boolean isExternalStorageDocument(Uri uri) {
return "com.android.externalstorage.documents".equals(uri.getAuthority());
}
/**
* @param uri The Uri to check.
* @return Whether the Uri authority is DownloadsProvider.
*/
public static boolean isDownloadsDocument(Uri uri) {
return "com.android.providers.downloads.documents".equals(uri.getAuthority());
}
/**
* @param uri The Uri to check.
* @return Whether the Uri authority is MediaProvider.
*/
public static boolean isMediaDocument(Uri uri) {
return "com.android.providers.media.documents".equals(uri.getAuthority());
}
Resumen de esta sección:
Bien, sobre la sección del marco de acceso al almacenamiento (SAF) de Android, dejémoslo aquí. No hay ejemplos, cuando lo usemos más adelante lo estudiaremos en profundidad. Solo hay que saberlo; después de 4.4 obtener la ruta del archivo es mucho más simple ~
