Add DocumentsProvider
This commit is contained in:
leo60228
Misa Elizabeth Kai
parent
9d1d994f57
commit
2986dc01d9
|
|
@ -13,13 +13,13 @@ android {
|
|||
}
|
||||
compileSdkVersion 34
|
||||
defaultConfig {
|
||||
minSdkVersion 19
|
||||
minSdkVersion 29
|
||||
targetSdkVersion 34
|
||||
versionCode 1
|
||||
versionName "1.0"
|
||||
externalNativeBuild {
|
||||
cmake {
|
||||
arguments "-DANDROID_APP_PLATFORM=android-19", "-DANDROID_STL=c++_static"
|
||||
arguments "-DANDROID_APP_PLATFORM=android-29", "-DANDROID_STL=c++_static"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -98,4 +98,7 @@ project.android.applicationVariants.configureEach { variant ->
|
|||
|
||||
dependencies {
|
||||
implementation fileTree(include: ['*.jar'], dir: 'libs')
|
||||
implementation 'org.jetbrains:annotations:15.0'
|
||||
implementation 'androidx.core:core:1.10.1'
|
||||
implementation 'androidx.exifinterface:exifinterface:1.3.6'
|
||||
}
|
||||
|
|
|
|||
|
|
@ -96,6 +96,17 @@
|
|||
</intent-filter>
|
||||
-->
|
||||
</activity>
|
||||
|
||||
<provider
|
||||
android:name="com.distractionware.vvvvvv.BaseDirProvider"
|
||||
android:authorities="com.distractionware.vvvvvv.basedir"
|
||||
android:grantUriPermissions="true"
|
||||
android:exported="true"
|
||||
android:permission="android.permission.MANAGE_DOCUMENTS">
|
||||
<intent-filter>
|
||||
<action android:name="android.content.action.DOCUMENTS_PROVIDER" />
|
||||
</intent-filter>
|
||||
</provider>
|
||||
</application>
|
||||
|
||||
</manifest>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,85 @@
|
|||
package com.distractionware.vvvvvv;
|
||||
|
||||
import android.database.Cursor;
|
||||
import android.database.MatrixCursor;
|
||||
import android.database.MatrixCursor.RowBuilder;
|
||||
import android.net.Uri;
|
||||
import android.provider.DocumentsContract;
|
||||
import android.provider.DocumentsContract.Document;
|
||||
import android.provider.DocumentsContract.Root;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
|
||||
public class BaseDirProvider extends FileSystemProvider {
|
||||
private static final String AUTHORITY = "com.distractionware.vvvvvv.basedir";
|
||||
private static final String DOC_ID_ROOT = "vvvvvv";
|
||||
|
||||
private static final String[] DEFAULT_ROOT_PROJECTION = new String[]{
|
||||
Root.COLUMN_ROOT_ID, Root.COLUMN_FLAGS, Root.COLUMN_ICON, Root.COLUMN_TITLE,
|
||||
Root.COLUMN_DOCUMENT_ID,
|
||||
};
|
||||
|
||||
private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[]{
|
||||
Document.COLUMN_DOCUMENT_ID, Document.COLUMN_MIME_TYPE, Document.COLUMN_DISPLAY_NAME,
|
||||
Document.COLUMN_LAST_MODIFIED, Document.COLUMN_FLAGS, Document.COLUMN_SIZE,
|
||||
};
|
||||
|
||||
private File mRoot;
|
||||
|
||||
@Override
|
||||
public boolean onCreate() {
|
||||
super.onCreate(DEFAULT_DOCUMENT_PROJECTION);
|
||||
mRoot = getContext().getExternalFilesDir(null);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Cursor queryRoots(String[] projection) throws FileNotFoundException {
|
||||
final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection));
|
||||
final RowBuilder row = result.newRow();
|
||||
row.add(Root.COLUMN_ROOT_ID, DOC_ID_ROOT);
|
||||
row.add(Root.COLUMN_FLAGS,
|
||||
Root.FLAG_LOCAL_ONLY | Root.FLAG_SUPPORTS_CREATE | Root.FLAG_SUPPORTS_SEARCH |
|
||||
Root.FLAG_SUPPORTS_IS_CHILD);
|
||||
row.add(Root.COLUMN_ICON, R.mipmap.ic_launcher);
|
||||
row.add(Root.COLUMN_TITLE, "VVVVVV");
|
||||
row.add(Root.COLUMN_DOCUMENT_ID, DOC_ID_ROOT);
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected Uri buildNotificationUri(String docId) {
|
||||
return DocumentsContract.buildChildDocumentsUri(AUTHORITY, docId);
|
||||
}
|
||||
|
||||
private static String[] resolveRootProjection(String[] projection) {
|
||||
return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
|
||||
}
|
||||
|
||||
private static String[] resolveDocumentProjection(String[] projection) {
|
||||
return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String getDocIdForFile(File file) {
|
||||
return "raw:" + file.getAbsolutePath();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected File getFileForDocId(String documentId, boolean visible)
|
||||
throws FileNotFoundException {
|
||||
if (DOC_ID_ROOT.equals(documentId)) {
|
||||
return mRoot;
|
||||
} else if (documentId.startsWith("raw:")) {
|
||||
final String name = documentId.substring(4);
|
||||
final File file = new File(name);
|
||||
if (!file.exists()) {
|
||||
throw new FileNotFoundException("File not found: " + name);
|
||||
}
|
||||
return file;
|
||||
} else {
|
||||
throw new FileNotFoundException("Invalid document ID: " + documentId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,936 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package com.distractionware.vvvvvv;
|
||||
|
||||
import static android.provider.DocumentsContract.EXTRA_ORIENTATION;
|
||||
import static android.provider.DocumentsContract.QUERY_ARG_DISPLAY_NAME;
|
||||
import static android.provider.DocumentsContract.QUERY_ARG_EXCLUDE_MEDIA;
|
||||
import static android.provider.DocumentsContract.QUERY_ARG_FILE_SIZE_OVER;
|
||||
import static android.provider.DocumentsContract.QUERY_ARG_LAST_MODIFIED_AFTER;
|
||||
import static android.provider.DocumentsContract.QUERY_ARG_MIME_TYPES;
|
||||
|
||||
import android.content.ContentResolver;
|
||||
import android.content.Context;
|
||||
import android.content.Intent;
|
||||
import android.content.res.AssetFileDescriptor;
|
||||
import android.database.Cursor;
|
||||
import android.database.MatrixCursor;
|
||||
import android.database.MatrixCursor.RowBuilder;
|
||||
import android.graphics.Point;
|
||||
import android.media.MediaScannerConnection;
|
||||
import android.net.Uri;
|
||||
import android.os.Bundle;
|
||||
import android.os.CancellationSignal;
|
||||
import android.os.FileObserver;
|
||||
import android.os.Handler;
|
||||
import android.os.ParcelFileDescriptor;
|
||||
import android.provider.DocumentsContract;
|
||||
import android.provider.DocumentsContract.Document;
|
||||
import android.provider.DocumentsProvider;
|
||||
import android.text.TextUtils;
|
||||
import android.util.ArrayMap;
|
||||
import android.util.Log;
|
||||
import android.webkit.MimeTypeMap;
|
||||
|
||||
import androidx.core.content.MimeTypeFilter;
|
||||
import androidx.exifinterface.media.ExifInterface;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Objects;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
/**
|
||||
* A helper class for {@link android.provider.DocumentsProvider} to perform file operations on local
|
||||
* files.
|
||||
*/
|
||||
public abstract class FileSystemProvider extends DocumentsProvider {
|
||||
|
||||
private static final String TAG = "FileSystemProvider";
|
||||
|
||||
private static final boolean LOG_INOTIFY = false;
|
||||
|
||||
protected static final String SUPPORTED_QUERY_ARGS = joinNewline(
|
||||
QUERY_ARG_DISPLAY_NAME,
|
||||
QUERY_ARG_FILE_SIZE_OVER,
|
||||
QUERY_ARG_LAST_MODIFIED_AFTER,
|
||||
QUERY_ARG_MIME_TYPES);
|
||||
|
||||
private static String joinNewline(String... args) {
|
||||
return TextUtils.join("\n", args);
|
||||
}
|
||||
|
||||
private String[] mDefaultProjection;
|
||||
|
||||
private final ArrayMap<File, DirectoryObserver> mObservers = new ArrayMap<>();
|
||||
|
||||
private Handler mHandler;
|
||||
|
||||
protected abstract File getFileForDocId(String docId, boolean visible)
|
||||
throws FileNotFoundException;
|
||||
|
||||
protected abstract String getDocIdForFile(File file) throws FileNotFoundException;
|
||||
|
||||
protected abstract Uri buildNotificationUri(String docId);
|
||||
|
||||
/**
|
||||
* Callback indicating that the given document has been modified. This gives the provider a hook
|
||||
* to invalidate cached data, such as {@code sdcardfs}.
|
||||
*/
|
||||
protected void onDocIdChanged(String docId) {
|
||||
// Default is no-op
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback indicating that the given document has been deleted or moved. This gives the
|
||||
* provider a hook to revoke the uri permissions.
|
||||
*/
|
||||
protected void onDocIdDeleted(String docId) {
|
||||
// Default is no-op
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onCreate() {
|
||||
throw new UnsupportedOperationException(
|
||||
"Subclass should override this and call onCreate(defaultDocumentProjection)");
|
||||
}
|
||||
|
||||
protected void onCreate(String[] defaultProjection) {
|
||||
mHandler = new Handler();
|
||||
mDefaultProjection = defaultProjection;
|
||||
}
|
||||
|
||||
private static boolean contains(String dirPath, String filePath) {
|
||||
if (dirPath.equals(filePath)) {
|
||||
return true;
|
||||
}
|
||||
if (!dirPath.endsWith("/")) {
|
||||
dirPath += "/";
|
||||
}
|
||||
return filePath.startsWith(dirPath);
|
||||
}
|
||||
|
||||
private static boolean contains(File dir, File file) {
|
||||
if (dir == null || file == null) return false;
|
||||
return contains(dir.getAbsolutePath(), file.getAbsolutePath());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isChildDocument(String parentDocId, String docId) {
|
||||
try {
|
||||
final File parent = getFileForDocId(parentDocId).getCanonicalFile();
|
||||
final File doc = getFileForDocId(docId).getCanonicalFile();
|
||||
return contains(parent, doc);
|
||||
} catch (IOException e) {
|
||||
throw new IllegalArgumentException(
|
||||
"Failed to determine if " + docId + " is child of " + parentDocId + ": " + e);
|
||||
}
|
||||
}
|
||||
|
||||
protected final List<String> findDocumentPath(File parent, File doc)
|
||||
throws FileNotFoundException {
|
||||
|
||||
if (!doc.exists()) {
|
||||
throw new FileNotFoundException(doc + " is not found.");
|
||||
}
|
||||
|
||||
if (!contains(parent, doc)) {
|
||||
throw new FileNotFoundException(doc + " is not found under " + parent);
|
||||
}
|
||||
|
||||
LinkedList<String> path = new LinkedList<>();
|
||||
while (doc != null && contains(parent, doc)) {
|
||||
path.addFirst(getDocIdForFile(doc));
|
||||
|
||||
doc = doc.getParentFile();
|
||||
}
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
private static boolean isValidFatFilenameChar(char c) {
|
||||
if ((0x00 <= c && c <= 0x1f)) {
|
||||
return false;
|
||||
}
|
||||
switch (c) {
|
||||
case '"':
|
||||
case '*':
|
||||
case '/':
|
||||
case ':':
|
||||
case '<':
|
||||
case '>':
|
||||
case '?':
|
||||
case '\\':
|
||||
case '|':
|
||||
case 0x7F:
|
||||
return false;
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private static String buildValidFatFilename(String name) {
|
||||
if (TextUtils.isEmpty(name) || ".".equals(name) || "..".equals(name)) {
|
||||
return "(invalid)";
|
||||
}
|
||||
final StringBuilder res = new StringBuilder(name.length());
|
||||
for (int i = 0; i < name.length(); i++) {
|
||||
final char c = name.charAt(i);
|
||||
if (isValidFatFilenameChar(c)) {
|
||||
res.append(c);
|
||||
} else {
|
||||
res.append('_');
|
||||
}
|
||||
}
|
||||
// Even though vfat allows 255 UCS-2 chars, we might eventually write to
|
||||
// ext4 through a FUSE layer, so use that limit.
|
||||
trimFilename(res, 255);
|
||||
return res.toString();
|
||||
}
|
||||
|
||||
private static String trimFilename(String str, int maxBytes) {
|
||||
final StringBuilder res = new StringBuilder(str);
|
||||
trimFilename(res, maxBytes);
|
||||
return res.toString();
|
||||
}
|
||||
|
||||
private static void trimFilename(StringBuilder res, int maxBytes) {
|
||||
byte[] raw = res.toString().getBytes(StandardCharsets.UTF_8);
|
||||
if (raw.length > maxBytes) {
|
||||
maxBytes -= 3;
|
||||
while (raw.length > maxBytes) {
|
||||
res.deleteCharAt(res.length() / 2);
|
||||
raw = res.toString().getBytes(StandardCharsets.UTF_8);
|
||||
}
|
||||
res.insert(res.length() / 2, "...");
|
||||
}
|
||||
}
|
||||
|
||||
private static File buildFile(File parent, String name, String ext) {
|
||||
if (TextUtils.isEmpty(ext)) {
|
||||
return new File(parent, name);
|
||||
} else {
|
||||
return new File(parent, name + "." + ext);
|
||||
}
|
||||
}
|
||||
|
||||
private static File buildUniqueFileWithExtension(File parent, String name, String ext)
|
||||
throws FileNotFoundException {
|
||||
File file = buildFile(parent, name, ext);
|
||||
// If conflicting file, try adding counter suffix
|
||||
int n = 0;
|
||||
while (file.exists()) {
|
||||
if (n++ >= 32) {
|
||||
throw new FileNotFoundException("Failed to create unique file");
|
||||
}
|
||||
file = buildFile(parent, name + " (" + n + ")", ext);
|
||||
}
|
||||
return file;
|
||||
}
|
||||
|
||||
private static String[] splitFileName(String mimeType, String displayName) {
|
||||
String name;
|
||||
String ext;
|
||||
if (Document.MIME_TYPE_DIR.equals(mimeType)) {
|
||||
name = displayName;
|
||||
ext = null;
|
||||
} else {
|
||||
String mimeTypeFromExt;
|
||||
// Extract requested extension from display name
|
||||
final int lastDot = displayName.lastIndexOf('.');
|
||||
if (lastDot >= 0) {
|
||||
name = displayName.substring(0, lastDot);
|
||||
ext = displayName.substring(lastDot + 1);
|
||||
mimeTypeFromExt = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
|
||||
ext.toLowerCase());
|
||||
} else {
|
||||
name = displayName;
|
||||
ext = null;
|
||||
mimeTypeFromExt = null;
|
||||
}
|
||||
if (mimeTypeFromExt == null) {
|
||||
mimeTypeFromExt = "application/octet-stream";
|
||||
}
|
||||
final String extFromMimeType;
|
||||
if ("application/octet-stream".equals(mimeType)) {
|
||||
extFromMimeType = null;
|
||||
} else {
|
||||
extFromMimeType = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
|
||||
}
|
||||
if (Objects.equals(mimeType, mimeTypeFromExt) || Objects.equals(ext, extFromMimeType)) {
|
||||
// Extension maps back to requested MIME type; allow it
|
||||
} else {
|
||||
// No match; insist that create file matches requested MIME
|
||||
name = displayName;
|
||||
ext = extFromMimeType;
|
||||
}
|
||||
}
|
||||
if (ext == null) {
|
||||
ext = "";
|
||||
}
|
||||
return new String[]{name, ext};
|
||||
}
|
||||
|
||||
private static File buildUniqueFile(File parent, String mimeType, String displayName)
|
||||
throws FileNotFoundException {
|
||||
final String[] parts = splitFileName(mimeType, displayName);
|
||||
return buildUniqueFileWithExtension(parent, parts[0], parts[1]);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String createDocument(String docId, String mimeType, String displayName)
|
||||
throws FileNotFoundException {
|
||||
displayName = buildValidFatFilename(displayName);
|
||||
|
||||
final File parent = getFileForDocId(docId);
|
||||
if (!parent.isDirectory()) {
|
||||
throw new IllegalArgumentException("Parent document isn't a directory");
|
||||
}
|
||||
|
||||
final File file = buildUniqueFile(parent, mimeType, displayName);
|
||||
final String childId;
|
||||
if (Document.MIME_TYPE_DIR.equals(mimeType)) {
|
||||
if (!file.mkdir()) {
|
||||
throw new IllegalStateException("Failed to mkdir " + file);
|
||||
}
|
||||
childId = getDocIdForFile(file);
|
||||
onDocIdChanged(childId);
|
||||
} else {
|
||||
try {
|
||||
if (!file.createNewFile()) {
|
||||
throw new IllegalStateException("Failed to touch " + file);
|
||||
}
|
||||
childId = getDocIdForFile(file);
|
||||
onDocIdChanged(childId);
|
||||
} catch (IOException e) {
|
||||
throw new IllegalStateException("Failed to touch " + file + ": " + e);
|
||||
}
|
||||
}
|
||||
updateMediaStore(getContext(), file);
|
||||
return childId;
|
||||
}
|
||||
|
||||
private static File buildUniqueFile(File parent, String displayName)
|
||||
throws FileNotFoundException {
|
||||
final String name;
|
||||
final String ext;
|
||||
// Extract requested extension from display name
|
||||
final int lastDot = displayName.lastIndexOf('.');
|
||||
if (lastDot >= 0) {
|
||||
name = displayName.substring(0, lastDot);
|
||||
ext = displayName.substring(lastDot + 1);
|
||||
} else {
|
||||
name = displayName;
|
||||
ext = null;
|
||||
}
|
||||
return buildUniqueFileWithExtension(parent, name, ext);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String renameDocument(String docId, String displayName) throws FileNotFoundException {
|
||||
// Since this provider treats renames as generating a completely new
|
||||
// docId, we're okay with letting the MIME type change.
|
||||
displayName = buildValidFatFilename(displayName);
|
||||
|
||||
final File before = getFileForDocId(docId);
|
||||
final File beforeVisibleFile = getFileForDocId(docId, true);
|
||||
final File after = buildUniqueFile(before.getParentFile(), displayName);
|
||||
if (!before.renameTo(after)) {
|
||||
throw new IllegalStateException("Failed to rename to " + after);
|
||||
}
|
||||
|
||||
final String afterDocId = getDocIdForFile(after);
|
||||
onDocIdChanged(docId);
|
||||
onDocIdDeleted(docId);
|
||||
onDocIdChanged(afterDocId);
|
||||
|
||||
final File afterVisibleFile = getFileForDocId(afterDocId, true);
|
||||
|
||||
updateMediaStore(getContext(), beforeVisibleFile);
|
||||
updateMediaStore(getContext(), afterVisibleFile);
|
||||
|
||||
if (!TextUtils.equals(docId, afterDocId)) {
|
||||
return afterDocId;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String moveDocument(String sourceDocumentId, String sourceParentDocumentId,
|
||||
String targetParentDocumentId)
|
||||
throws FileNotFoundException {
|
||||
final File before = getFileForDocId(sourceDocumentId);
|
||||
final File after = new File(getFileForDocId(targetParentDocumentId), before.getName());
|
||||
final File visibleFileBefore = getFileForDocId(sourceDocumentId, true);
|
||||
|
||||
if (after.exists()) {
|
||||
throw new IllegalStateException("Already exists " + after);
|
||||
}
|
||||
if (!before.renameTo(after)) {
|
||||
throw new IllegalStateException("Failed to move to " + after);
|
||||
}
|
||||
|
||||
final String docId = getDocIdForFile(after);
|
||||
onDocIdChanged(sourceDocumentId);
|
||||
onDocIdDeleted(sourceDocumentId);
|
||||
onDocIdChanged(docId);
|
||||
// update the database
|
||||
updateMediaStore(getContext(), visibleFileBefore);
|
||||
updateMediaStore(getContext(), getFileForDocId(docId, true));
|
||||
return docId;
|
||||
}
|
||||
|
||||
private static void updateMediaStore(@NotNull Context context, File file) {
|
||||
if (file != null) {
|
||||
final ContentResolver resolver = context.getContentResolver();
|
||||
final String noMedia = ".nomedia";
|
||||
// For file, check whether the file name is .nomedia or not.
|
||||
// If yes, scan the parent directory to update all files in the directory.
|
||||
if (!file.isDirectory() && file.getName().toLowerCase(Locale.ROOT).endsWith(noMedia)) {
|
||||
MediaScannerConnection.scanFile(context, new String[]{file.getParent()}, null,
|
||||
null);
|
||||
} else {
|
||||
MediaScannerConnection.scanFile(context, new String[]{file.getParent()}, null,
|
||||
null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean deleteContents(File dir) {
|
||||
File[] files = dir.listFiles();
|
||||
boolean success = true;
|
||||
if (files != null) {
|
||||
for (File file : files) {
|
||||
if (file.isDirectory()) {
|
||||
success &= deleteContents(file);
|
||||
}
|
||||
if (!file.delete()) {
|
||||
Log.w(TAG, "Failed to delete " + file);
|
||||
success = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return success;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteDocument(String docId) throws FileNotFoundException {
|
||||
final File file = getFileForDocId(docId);
|
||||
final File visibleFile = getFileForDocId(docId, true);
|
||||
|
||||
final boolean isDirectory = file.isDirectory();
|
||||
if (isDirectory) {
|
||||
deleteContents(file);
|
||||
}
|
||||
// We could be deleting pending media which doesn't have any content yet, so only throw
|
||||
// if the file exists and we fail to delete it.
|
||||
if (file.exists() && !file.delete()) {
|
||||
throw new IllegalStateException("Failed to delete " + file);
|
||||
}
|
||||
|
||||
onDocIdChanged(docId);
|
||||
onDocIdDeleted(docId);
|
||||
updateMediaStore(getContext(), visibleFile);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Cursor queryDocument(String documentId, String[] projection)
|
||||
throws FileNotFoundException {
|
||||
final MatrixCursor result = new MatrixCursor(resolveProjection(projection));
|
||||
includeFile(result, documentId, null);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is similar to
|
||||
* {@link DocumentsProvider#queryChildDocuments(String, String[], String)}. This method returns
|
||||
* all children documents including hidden directories/files.
|
||||
*
|
||||
* <p>
|
||||
* In a scoped storage world, access to "Android/data" style directories are hidden for privacy
|
||||
* reasons. This method may show privacy sensitive data, so its usage should only be in
|
||||
* restricted modes.
|
||||
*
|
||||
* @param parentDocumentId the directory to return children for.
|
||||
* @param projection list of {@link Document} columns to put into the cursor. If
|
||||
* {@code null} all supported columns should be included.
|
||||
* @param sortOrder how to order the rows, formatted as an SQL {@code ORDER BY} clause
|
||||
* (excluding the ORDER BY itself). Passing {@code null} will use the
|
||||
* default sort order, which may be unordered. This ordering is a hint
|
||||
* that can be used to prioritize how data is fetched from the network,
|
||||
* but UI may always enforce a specific ordering
|
||||
* @throws FileNotFoundException when parent document doesn't exist or query fails
|
||||
*/
|
||||
protected Cursor queryChildDocumentsShowAll(
|
||||
String parentDocumentId, String[] projection, String sortOrder)
|
||||
throws FileNotFoundException {
|
||||
return queryChildDocuments(parentDocumentId, projection, sortOrder, File -> true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Cursor queryChildDocuments(
|
||||
String parentDocumentId, String[] projection, String sortOrder)
|
||||
throws FileNotFoundException {
|
||||
// Access to some directories is hidden for privacy reasons.
|
||||
return queryChildDocuments(parentDocumentId, projection, sortOrder, this::shouldShow);
|
||||
}
|
||||
|
||||
private static @NotNull File[] listFilesOrEmpty(@Nullable File dir) {
|
||||
if (dir == null) {
|
||||
return new File[]{};
|
||||
} else {
|
||||
File[] files = dir.listFiles();
|
||||
if (files == null) {
|
||||
return new File[]{};
|
||||
} else {
|
||||
return files;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private Cursor queryChildDocuments(
|
||||
String parentDocumentId, String[] projection, String sortOrder,
|
||||
@NotNull Predicate<File> filter) throws FileNotFoundException {
|
||||
final File parent = getFileForDocId(parentDocumentId);
|
||||
final MatrixCursor result = new DirectoryCursor(
|
||||
resolveProjection(projection), parentDocumentId, parent);
|
||||
|
||||
if (!filter.test(parent)) {
|
||||
Log.w(TAG, "No permission to access parentDocumentId: " + parentDocumentId);
|
||||
return result;
|
||||
}
|
||||
|
||||
if (parent.isDirectory()) {
|
||||
for (File file : listFilesOrEmpty(parent)) {
|
||||
if (filter.test(file)) {
|
||||
includeFile(result, null, file);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Log.w(TAG, "parentDocumentId '" + parentDocumentId + "' is not Directory");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private static String[] getHandledQueryArguments(Bundle queryArgs) {
|
||||
if (queryArgs == null) {
|
||||
return new String[0];
|
||||
}
|
||||
final ArrayList<String> args = new ArrayList<>();
|
||||
if (queryArgs.keySet().contains(QUERY_ARG_EXCLUDE_MEDIA)) {
|
||||
args.add(QUERY_ARG_EXCLUDE_MEDIA);
|
||||
}
|
||||
if (queryArgs.keySet().contains(QUERY_ARG_DISPLAY_NAME)) {
|
||||
args.add(QUERY_ARG_DISPLAY_NAME);
|
||||
}
|
||||
if (queryArgs.keySet().contains(QUERY_ARG_FILE_SIZE_OVER)) {
|
||||
args.add(QUERY_ARG_FILE_SIZE_OVER);
|
||||
}
|
||||
if (queryArgs.keySet().contains(QUERY_ARG_LAST_MODIFIED_AFTER)) {
|
||||
args.add(QUERY_ARG_LAST_MODIFIED_AFTER);
|
||||
}
|
||||
if (queryArgs.keySet().contains(QUERY_ARG_MIME_TYPES)) {
|
||||
args.add(QUERY_ARG_MIME_TYPES);
|
||||
}
|
||||
return args.toArray(new String[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches documents under the given folder.
|
||||
* <p>
|
||||
* To avoid runtime explosion only returns the at most 23 items.
|
||||
*
|
||||
* @param folder the root folder where recursive search begins
|
||||
* @param projection projection of the returned cursor
|
||||
* @param exclusion absolute file paths to exclude from result
|
||||
* @param queryArgs the query arguments for search
|
||||
* @return cursor containing search result. Include {@link ContentResolver#EXTRA_HONORED_ARGS}
|
||||
* in {@link Cursor} extras {@link Bundle} when any QUERY_ARG_* value was honored during the
|
||||
* preparation of the results.
|
||||
* @throws FileNotFoundException when root folder doesn't exist or search fails
|
||||
* @see ContentResolver#EXTRA_HONORED_ARGS
|
||||
*/
|
||||
protected final Cursor querySearchDocuments(
|
||||
File folder, String[] projection, Set<String> exclusion, Bundle queryArgs)
|
||||
throws FileNotFoundException {
|
||||
final MatrixCursor result = new MatrixCursor(resolveProjection(projection));
|
||||
final LinkedList<File> pending = new LinkedList<>();
|
||||
pending.add(folder);
|
||||
while (!pending.isEmpty() && result.getCount() < 24) {
|
||||
final File file = pending.removeFirst();
|
||||
if (shouldHide(file)) continue;
|
||||
|
||||
if (file.isDirectory()) {
|
||||
for (File child : listFilesOrEmpty(file)) {
|
||||
pending.add(child);
|
||||
}
|
||||
}
|
||||
if (!exclusion.contains(file.getAbsolutePath()) && matchSearchQueryArguments(file,
|
||||
queryArgs)) {
|
||||
includeFile(result, null, file);
|
||||
}
|
||||
}
|
||||
|
||||
final String[] handledQueryArgs = getHandledQueryArguments(queryArgs);
|
||||
if (handledQueryArgs.length > 0) {
|
||||
final Bundle extras = new Bundle();
|
||||
extras.putStringArray(ContentResolver.EXTRA_HONORED_ARGS, handledQueryArgs);
|
||||
result.setExtras(extras);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDocumentType(String documentId) throws FileNotFoundException {
|
||||
return getDocumentType(documentId, getFileForDocId(documentId));
|
||||
}
|
||||
|
||||
private String getDocumentType(final String documentId, final File file)
|
||||
throws FileNotFoundException {
|
||||
if (file.isDirectory()) {
|
||||
return Document.MIME_TYPE_DIR;
|
||||
} else {
|
||||
final int lastDot = documentId.lastIndexOf('.');
|
||||
if (lastDot >= 0) {
|
||||
final String extension = documentId.substring(lastDot + 1).toLowerCase();
|
||||
final String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
|
||||
if (mime != null) {
|
||||
return mime;
|
||||
}
|
||||
}
|
||||
return "application/octet-stream";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public ParcelFileDescriptor openDocument(
|
||||
String documentId, String mode, CancellationSignal signal)
|
||||
throws FileNotFoundException {
|
||||
final File file = getFileForDocId(documentId);
|
||||
final File visibleFile = getFileForDocId(documentId, true);
|
||||
|
||||
final int pfdMode = ParcelFileDescriptor.parseMode(mode);
|
||||
if (visibleFile == null || pfdMode == ParcelFileDescriptor.MODE_READ_ONLY) {
|
||||
return ParcelFileDescriptor.open(file, pfdMode);
|
||||
} else {
|
||||
try {
|
||||
// When finished writing, kick off media scanner
|
||||
return ParcelFileDescriptor.open(
|
||||
file, pfdMode, mHandler, (IOException e) -> {
|
||||
onDocIdChanged(documentId);
|
||||
scanFile(visibleFile);
|
||||
});
|
||||
} catch (IOException e) {
|
||||
throw new FileNotFoundException("Failed to open for writing: " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean matchSearchQueryArguments(Bundle queryArgs, String displayName,
|
||||
String mimeType, long lastModified, long size) {
|
||||
if (queryArgs == null) {
|
||||
return true;
|
||||
}
|
||||
final String argDisplayName = queryArgs.getString(QUERY_ARG_DISPLAY_NAME, "");
|
||||
if (!argDisplayName.isEmpty()) {
|
||||
// TODO (118795812) : Enhance the search string handled in DocumentsProvider
|
||||
if (!displayName.toLowerCase().contains(argDisplayName.toLowerCase())) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
final long argFileSize = queryArgs.getLong(QUERY_ARG_FILE_SIZE_OVER, -1 /* defaultValue */);
|
||||
if (argFileSize != -1 && size < argFileSize) {
|
||||
return false;
|
||||
}
|
||||
final long argLastModified = queryArgs.getLong(QUERY_ARG_LAST_MODIFIED_AFTER,
|
||||
-1 /* defaultValue */);
|
||||
if (argLastModified != -1 && lastModified < argLastModified) {
|
||||
return false;
|
||||
}
|
||||
final String[] argMimeTypes = queryArgs.getStringArray(QUERY_ARG_MIME_TYPES);
|
||||
if (argMimeTypes != null && argMimeTypes.length > 0) {
|
||||
mimeType = Intent.normalizeMimeType(mimeType);
|
||||
for (String type : argMimeTypes) {
|
||||
if (MimeTypeFilter.matches(mimeType, Intent.normalizeMimeType(type))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if the file matches the query arguments.
|
||||
*
|
||||
* @param file the file to test
|
||||
* @param queryArgs the query arguments
|
||||
*/
|
||||
private boolean matchSearchQueryArguments(File file, Bundle queryArgs) {
|
||||
if (file == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
final String fileMimeType;
|
||||
final String fileName = file.getName();
|
||||
|
||||
if (file.isDirectory()) {
|
||||
fileMimeType = DocumentsContract.Document.MIME_TYPE_DIR;
|
||||
} else {
|
||||
int dotPos = fileName.lastIndexOf('.');
|
||||
if (dotPos < 0) {
|
||||
return false;
|
||||
}
|
||||
final String extension = fileName.substring(dotPos + 1);
|
||||
fileMimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
|
||||
}
|
||||
return matchSearchQueryArguments(queryArgs, fileName, fileMimeType,
|
||||
file.lastModified(), file.length());
|
||||
}
|
||||
|
||||
private void scanFile(File visibleFile) {
|
||||
final Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
|
||||
intent.setData(Uri.fromFile(visibleFile));
|
||||
getContext().sendBroadcast(intent);
|
||||
}
|
||||
|
||||
private static AssetFileDescriptor openImageThumbnail(File file) throws FileNotFoundException {
|
||||
final ParcelFileDescriptor pfd = ParcelFileDescriptor.open(
|
||||
file, ParcelFileDescriptor.MODE_READ_ONLY);
|
||||
try {
|
||||
final ExifInterface exif = new ExifInterface(file.getAbsolutePath());
|
||||
final long[] thumb = exif.getThumbnailRange();
|
||||
if (thumb != null) {
|
||||
// If we use thumb to decode, we need to handle the rotation by ourselves.
|
||||
Bundle extras = null;
|
||||
switch (exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1)) {
|
||||
case ExifInterface.ORIENTATION_ROTATE_90:
|
||||
extras = new Bundle(1);
|
||||
extras.putInt(EXTRA_ORIENTATION, 90);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_180:
|
||||
extras = new Bundle(1);
|
||||
extras.putInt(EXTRA_ORIENTATION, 180);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_270:
|
||||
extras = new Bundle(1);
|
||||
extras.putInt(EXTRA_ORIENTATION, 270);
|
||||
break;
|
||||
}
|
||||
return new AssetFileDescriptor(pfd, thumb[0], thumb[1], extras);
|
||||
}
|
||||
} catch (IOException ignored) {
|
||||
}
|
||||
// Do full file decoding, we don't need to handle the orientation
|
||||
return new AssetFileDescriptor(pfd, 0, AssetFileDescriptor.UNKNOWN_LENGTH, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public AssetFileDescriptor openDocumentThumbnail(
|
||||
String documentId, Point sizeHint, CancellationSignal signal)
|
||||
throws FileNotFoundException {
|
||||
final File file = getFileForDocId(documentId);
|
||||
return openImageThumbnail(file);
|
||||
}
|
||||
|
||||
protected RowBuilder includeFile(final MatrixCursor result, String docId, File file)
|
||||
throws FileNotFoundException {
|
||||
final String[] columns = result.getColumnNames();
|
||||
final RowBuilder row = result.newRow();
|
||||
|
||||
if (docId == null) {
|
||||
docId = getDocIdForFile(file);
|
||||
} else {
|
||||
file = getFileForDocId(docId);
|
||||
}
|
||||
|
||||
final String mimeType = getDocumentType(docId, file);
|
||||
row.add(Document.COLUMN_DOCUMENT_ID, docId);
|
||||
row.add(Document.COLUMN_MIME_TYPE, mimeType);
|
||||
|
||||
final int flagIndex = Arrays.asList(columns).indexOf(Document.COLUMN_FLAGS);
|
||||
if (flagIndex != -1) {
|
||||
int flags = 0;
|
||||
if (file.canWrite()) {
|
||||
if (mimeType.equals(Document.MIME_TYPE_DIR)) {
|
||||
flags |= Document.FLAG_DIR_SUPPORTS_CREATE;
|
||||
flags |= Document.FLAG_SUPPORTS_DELETE;
|
||||
flags |= Document.FLAG_SUPPORTS_RENAME;
|
||||
flags |= Document.FLAG_SUPPORTS_MOVE;
|
||||
} else {
|
||||
flags |= Document.FLAG_SUPPORTS_WRITE;
|
||||
flags |= Document.FLAG_SUPPORTS_DELETE;
|
||||
flags |= Document.FLAG_SUPPORTS_RENAME;
|
||||
flags |= Document.FLAG_SUPPORTS_MOVE;
|
||||
}
|
||||
}
|
||||
|
||||
if (mimeType.startsWith("image/")) {
|
||||
flags |= Document.FLAG_SUPPORTS_THUMBNAIL;
|
||||
}
|
||||
|
||||
if (typeSupportsMetadata(mimeType)) {
|
||||
flags |= Document.FLAG_SUPPORTS_METADATA;
|
||||
}
|
||||
row.add(Document.COLUMN_FLAGS, flags);
|
||||
}
|
||||
|
||||
final int displayNameIndex = Arrays.asList(columns).indexOf(Document.COLUMN_DISPLAY_NAME);
|
||||
if (displayNameIndex != -1) {
|
||||
row.add(Document.COLUMN_DISPLAY_NAME, file.getName());
|
||||
}
|
||||
|
||||
final int lastModifiedIndex = Arrays.asList(columns).indexOf(Document.COLUMN_LAST_MODIFIED);
|
||||
if (lastModifiedIndex != -1) {
|
||||
final long lastModified = file.lastModified();
|
||||
// Only publish dates reasonably after epoch
|
||||
if (lastModified > 31536000000L) {
|
||||
row.add(Document.COLUMN_LAST_MODIFIED, lastModified);
|
||||
}
|
||||
}
|
||||
final int sizeIndex = Arrays.asList(columns).indexOf(Document.COLUMN_SIZE);
|
||||
if (sizeIndex != -1) {
|
||||
row.add(Document.COLUMN_SIZE, file.length());
|
||||
}
|
||||
|
||||
// Return the row builder just in case any subclass want to add more stuff to it.
|
||||
return row;
|
||||
}
|
||||
|
||||
protected boolean shouldHide(@NotNull File file) {
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean shouldShow(@NotNull File file) {
|
||||
return !shouldHide(file);
|
||||
}
|
||||
|
||||
protected boolean typeSupportsMetadata(String mimeType) {
|
||||
return Document.MIME_TYPE_DIR.equals(mimeType);
|
||||
}
|
||||
|
||||
protected final File getFileForDocId(String docId) throws FileNotFoundException {
|
||||
return getFileForDocId(docId, false);
|
||||
}
|
||||
|
||||
private String[] resolveProjection(String[] projection) {
|
||||
return projection == null ? mDefaultProjection : projection;
|
||||
}
|
||||
|
||||
private void startObserving(File file, Uri notifyUri, DirectoryCursor cursor) {
|
||||
synchronized (mObservers) {
|
||||
DirectoryObserver observer = mObservers.get(file);
|
||||
if (observer == null) {
|
||||
observer =
|
||||
new DirectoryObserver(file, getContext().getContentResolver(), notifyUri);
|
||||
observer.startWatching();
|
||||
mObservers.put(file, observer);
|
||||
}
|
||||
observer.mCursors.add(cursor);
|
||||
|
||||
if (LOG_INOTIFY) Log.d(TAG, "after start: " + observer);
|
||||
}
|
||||
}
|
||||
|
||||
private void stopObserving(File file, DirectoryCursor cursor) {
|
||||
synchronized (mObservers) {
|
||||
DirectoryObserver observer = mObservers.get(file);
|
||||
if (observer == null) return;
|
||||
|
||||
observer.mCursors.remove(cursor);
|
||||
if (observer.mCursors.size() == 0) {
|
||||
mObservers.remove(file);
|
||||
observer.stopWatching();
|
||||
}
|
||||
|
||||
if (LOG_INOTIFY) Log.d(TAG, "after stop: " + observer);
|
||||
}
|
||||
}
|
||||
|
||||
private static class DirectoryObserver extends FileObserver {
|
||||
private static final int NOTIFY_EVENTS = ATTRIB | CLOSE_WRITE | MOVED_FROM | MOVED_TO
|
||||
| CREATE | DELETE | DELETE_SELF | MOVE_SELF;
|
||||
|
||||
private final File mFile;
|
||||
private final ContentResolver mResolver;
|
||||
private final Uri mNotifyUri;
|
||||
private final CopyOnWriteArrayList<DirectoryCursor> mCursors;
|
||||
|
||||
DirectoryObserver(File file, ContentResolver resolver, Uri notifyUri) {
|
||||
super(file.getAbsolutePath(), NOTIFY_EVENTS);
|
||||
mFile = file;
|
||||
mResolver = resolver;
|
||||
mNotifyUri = notifyUri;
|
||||
mCursors = new CopyOnWriteArrayList<>();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onEvent(int event, String path) {
|
||||
if ((event & NOTIFY_EVENTS) != 0) {
|
||||
if (LOG_INOTIFY) Log.d(TAG, "onEvent() " + event + " at " + path);
|
||||
for (DirectoryCursor cursor : mCursors) {
|
||||
cursor.notifyChanged();
|
||||
}
|
||||
mResolver.notifyChange(mNotifyUri, null, false);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
String filePath = mFile.getAbsolutePath();
|
||||
return "DirectoryObserver{file=" + filePath + ", ref=" + mCursors.size() + "}";
|
||||
}
|
||||
}
|
||||
|
||||
private class DirectoryCursor extends MatrixCursor {
|
||||
private final File mFile;
|
||||
|
||||
public DirectoryCursor(String[] columnNames, String docId, File file) {
|
||||
super(columnNames);
|
||||
|
||||
final Uri notifyUri = buildNotificationUri(docId);
|
||||
boolean registerSelfObserver = false; // Our FileObserver sees all relevant changes.
|
||||
setNotificationUris(getContext().getContentResolver(), Arrays.asList(notifyUri));
|
||||
|
||||
mFile = file;
|
||||
startObserving(mFile, notifyUri, this);
|
||||
}
|
||||
|
||||
public void notifyChanged() {
|
||||
onChange(false);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
super.close();
|
||||
stopObserving(mFile, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -15,3 +15,6 @@ org.gradle.jvmargs=-Xmx1536m -XX:-UseContainerSupport
|
|||
# This option should only be used with decoupled projects. More details, visit
|
||||
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
|
||||
# org.gradle.parallel=true
|
||||
|
||||
android.useAndroidX=true
|
||||
android.enableJetifier=true
|
||||
Loading…
Reference in New Issue