Einführung:

Nachdem Sie den vorherigen Abschnitt abgeschlossen haben, sollten Sie bereits wissen, wie Sie den vom System bereitgestellten ContentProvider verwenden oder einen benutzerdefinierten ContentProvider definieren, was im Grunde den täglichen Entwicklungsbedarf deckt. Interessanterweise habe ich diese anderen Provider in der offiziellen Dokumentation gesehen:

此处输入图片的描述

Calendar ProviderCalendar Provider: Eine Ressourcenbibliothek für kalenderbezogene Ereignisse. Über ihre API können wir CRUD-Operationen an Kalendern, Zeiten, Besprechungen, Erinnerungen und mehr durchführen!
Contacts ProviderContacts Provider: Dazu muss nicht mehr viel gesagt werden. Dieser wird am häufigsten verwendet. Ich werde diesen Artikel später übersetzen, wenn ich Zeit habe!
Storage Access Framework(SAF)Storage Access Framework: Ein neues Feature, das nach 4.4 eingeführt wurde und Benutzern den Komfort bietet, Speicherinhalte auf ihren Telefonen zu durchsuchen. Die zugänglichen Inhalte umfassen nicht nur Dokumente, Bilder, Videos, Audio und Downloads, sondern auch alle Inhalte, die von bestimmten ContentProviders bereitgestellt werden (die über die vereinbarte API verfügen müssen). Unabhängig davon, woher diese Inhalte stammen oder welche App den Befehl zum Durchsuchen von Systemdateiinhalten aufruft, stellt das System eine einheitliche Oberfläche zum Durchsuchen für Sie bereit.
Tatsächlich handelt es sich um eine integrierte Anwendung namens DocumentsUI. Da ihr IntentFilter nicht über LAUNCHER verfügt, finden wir dieses Ding nicht auf dem Desktop! Hehe, probieren Sie den folgenden Code aus. Hier haben wir zwei Telefone zum Vergleich ausgewählt: ein Lenovo S898T auf 4.2 und ein Nexus 5 auf 5.0.1. Führen Sie den folgenden Code aus:

 Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        intent.setType("image/*");
        startActivity(intent);
Das Folgende ist das Ausführungsergebnis:

Das rechte ist das Neue, das uns 4.4 gebracht hat. Wir können es im Allgemeinen verwenden, wenn wir eine Datei-URL abrufen müssen. Als Nächstes gehen wir kurz die Dokumentation durch.


2. Kurzer Durchgang durch die Dokumentation:

1) Komponenten des SAF-Frameworks:

  • DokumentanbieterDocumentsProvider: Ein spezieller ContentProvider, der es einem Speicherdienst (wie Google Drive) ermöglicht, die von ihm verwalteten Dateien nach außen verfügbar zu machen. Er istDocumentsProvidereine Unterklasse von ContentProvider. Darüber hinaus stimmt das Speicherformat von document-provider mit dem traditionellen Dateispeicherformat überein. Was die Speicherung Ihrer Inhalte betrifft, liegt es ganz bei Ihnen. Android hat mehrere solcher Dokumentanbieter integriert, wie beispielsweise für Downloads, Bilder und Videos!
  • Client-AppClient-Anwendung: Eine normale Client-Anwendung kann durch Auslösen vonACTION_OPEN_DOCUMENTund/oderACTION_CREATE_DOCUMENTden vom Dokumentanbieter zurückgegebenen Inhalt empfangen, zum Beispiel ein Bild auswählen und dann einen Uri zurückgeben.
  • PickerPicker: Eine Schnittstelle, die einem Dateimanager ähnelt, und es ist eine systemweite Schnittstelle, die einen Kanal bietet, um auf Inhalte von Dokumentanbietern zuzugreifen, die den Filterbedingungen des Clients entsprechen. Es ist das zuvor erwähnte DocumentsUI-Programm!

Einige Funktionen:

  • Benutzer können die von allen Dokumentanbietern bereitgestellten Inhalte durchsuchen, nicht nur die einer einzelnen Anwendung.
  • Es bietet langfristigen, anhaltenden Zugriff auf Dateien in Dokumentanbietern sowie Datenpersistenz. Benutzer können die vom Dokumentanbieter verwalteten Inhalte hinzufügen, löschen, bearbeiten und speichern.
  • Es unterstützt mehrere Benutzer und temporäre Content-Dienste. Beispielsweise erscheinen USB-Speicheranbieter erst, wenn der Treiber erfolgreich installiert wurde.

2) Überblick:

Der Kern von SAF ist eine Unterklasse, die DocumentsProvider implementiert, und sie ist weiterhin ein ContentProvider. Innerhalb eines Dokumentanbieters werden Dateien in einem traditionellen Dateiverzeichnisbaum organisiert:

3) Ablaufdiagramm:

Wie oben erwähnt, basieren die Daten eines Dokumentanbieters auf einer traditionellen Dateihierarchie, aber das ist nur die externe Darstellung. Wie Sie Ihre Daten speichern, bleibt ganz Ihnen überlassen, solange auf die Schnittstelle, die Sie nach außen bereitstellen, über die DocumentsProvider-API zugegriffen werden kann. Das folgende Ablaufdiagramm zeigt eine mögliche Struktur für eine Foto-App, die SAF verwendet:

Analyse:

Aus der obigen Abbildung können wir ersehen, dass der Picker eine Brücke ist, die den Aufrufer und die Content-Provider verbindet! Er stellt bereit und teilt dem Aufrufer mit, welche Content-Provider ausgewählt werden können, wie hier DriveDocProvider, UsbDocProvider und CloundDocProvider.
Wenn der ClientACTION_OPEN_DOCUMENToderACTION_CREATE_DOCUMENTden Intent auslöst, tritt die obige Interaktion auf. Natürlich können wir dem Intent auch Filterbedingungen hinzufügen, z. B. den MIME-Typ auf "image" beschränken!

Das ist alles zu dem oben Gesagten. Wenn Sie andere Bildanzeigesoftware installiert haben, erscheinen sie auch hier! Einfach ausgedrückt: Nachdem der Client einen Intent mit den beiden obigen Actions gesendet hat, wird die Picker-UI geöffnet. Die relevanten verfügbaren Dokumentanbieter werden hier angezeigt, damit der Benutzer sie auswählen kann. Nachdem der Benutzer ausgewählt hat, können die dateibezogenen Informationen abgerufen werden!


4) Client-Aufruf und Abrufen der zurückgegebenen Uri

Der Implementierungscode lautet wie folgt:

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

Ausführungsergebnis:Wenn wir beispielsweise diesen Hund auswählen, wird die Picker-UI automatisch geschlossen, und dann können wir eine solche uri in Logcat sehen:


5) Dateiparameter anhand der uri abrufen

Der Kerncode ist wie folgt:

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

Ausführungsergebnis:Immer noch dieser Hund. Nach dem Aufruf der Methode werden der Dateiname und die Dateigröße in Bytes ausgegeben.


6) Abrufen einer Bitmap aus der Uri

Der Kerncode ist wie folgt:

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

Ausführungsergebnis:

7) Abrufen eines Eingabestreams aus der Uri

Der Kerncode ist wie folgt:

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

Der obige Inhalt zeigt nur, was man über eine Uri herausfinden kann, und die Uri wird über SAF bezogen!


8) Neue Dateien erstellen und Dateien löschen:

Eine Datei erstellen:

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

Die Uri der erstellten Datei können Sie in onActivityResult() abrufen.

Eine Datei löschen:

Die Voraussetzung ist, dass Document.COLUMN_FLAGSSUPPORTS_DELETE enthält

DocumentsContract.deleteDocument(getContentResolver(), uri);

9) Schreiben eines benutzerdefinierten Dokumentanbieters

Wenn Sie möchten, dass die Daten Ihrer App auch in documentsui geöffnet werden können, müssen Sie Ihren eigenen Dokumentanbieter schreiben. Nachfolgend finden Sie die Schritte zum Definieren eines benutzerdefinierten DocumentsProvider:

  • API-Version 19 oder höher.
  • Registrieren Sie diesen Provider in manifest.xml.
  • Der Name des Providers ist der Klassenname plus Paketname, zum Beispiel:com.example.android.storageprovider.MyCloudProvider
  • Die Authority ist der Paketname + der Provider-Typname, zum Beispiel:com.example.android.storageprovider.documents
  • Der Wert des Attributs android:exported ist true.

Nachfolgend ein Beispiel, wie man den Provider schreibt:

<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) Unterklassen von DocumentsProvider

Implementieren Sie mindestens die folgenden Methoden:

  • queryRoots()
  • queryChildDocuments()
  • queryDocument()
  • openDocument()

Es gibt einige andere Methoden, aber sie sind nicht erforderlich. Nachfolgend finden Sie ein grobes Beispiel für die Implementierung eines DocumentsProvider, der auf das Dateisystem zugreift.

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

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

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

Nun, das ist ungefähr der gesamte Inhalt der Dokumentation. Zuerst wollte ich sie selbst übersetzen, aber später habe ich eine chinesische Übersetzung dieses Dokuments auf "Days Online" gefunden, also habe ich den faulen Weg gewählt~

Link zur chinesischen Übersetzung:Android Storage Access Framework


3. Das Problem beim Abrufen von Ressourcenpfaden in Android 4.4:

Tatsächlich ist der häufigste Anwendungsfall von SAF einfach, die Uri eines Bildes zu erhalten. Und aus dem obigen Beispiel haben wir auch festgestellt, dass der Link, den wir auf diese Weise erhalten, so aussieht:

content://com.android.providers.media.documents/document/image%3A69983

Für einen solchen Link können wir direkt die obige Methode verwenden, um die uri zu erhalten!

Natürlich gilt das für 4.4 oder höher.

Wenn es eine frühere Version ist, könnte die uri so aussehen:

content://media/external/images/media/image%3A69983

Hier ist eine umfassende Lösung, die ich woanders gesehen habe. Originallink:Das Problem beim Abrufen von Ressourcenpfaden in Android 4.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());
}

Zusammenfassung:

Okay, das war's für diesen Abschnitt über das Android Storage Access Framework (SAF). Es gibt keine Beispiele. Wir werden später tiefer graben, wenn wir es brauchen. Behalte es einfach im Hinterkopf. Nach 4.4 ist das Abrufen von Dateipfaden viel einfacher~