Strip out some logics from ESP to FSP that DSP can use. (75379db4) · Commits · e / os / android_frameworks_base

core/java/com/android/internal/content/FileSystemProvider.java

0 → 100644

+487 −0

Original line number	Diff line number	Diff line
		/*
		* 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.android.internal.content;

		import android.annotation.CallSuper;
		import android.content.ContentResolver;
		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.net.Uri;
		import android.os.CancellationSignal;
		import android.os.FileObserver;
		import android.os.FileUtils;
		import android.os.Handler;
		import android.os.ParcelFileDescriptor;
		import android.provider.DocumentsContract;
		import android.provider.DocumentsContract.Document;
		import android.provider.DocumentsProvider;
		import android.provider.MediaStore;
		import android.text.TextUtils;
		import android.util.ArrayMap;
		import android.util.Log;
		import android.webkit.MimeTypeMap;

		import com.android.internal.annotations.GuardedBy;

		import java.io.File;
		import java.io.FileNotFoundException;
		import java.io.IOException;
		import java.util.LinkedList;
		import java.util.List;
		import java.util.Set;

		/**
		* 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;

		private String[] mDefaultProjection;

		@GuardedBy("mObservers")
		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);

		@Override
		public boolean onCreate() {
		throw new UnsupportedOperationException(
		"Subclass should override this and call onCreate(defaultDocumentProjection)");
		}

		@CallSuper
		protected void onCreate(String[] defaultProjection) {
		mHandler = new Handler();
		mDefaultProjection = defaultProjection;
		}

		@Override
		public boolean isChildDocument(String parentDocId, String docId) {
		try {
		final File parent = getFileForDocId(parentDocId).getCanonicalFile();
		final File doc = getFileForDocId(docId).getCanonicalFile();
		return FileUtils.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 (!FileUtils.contains(parent, doc)) {
		throw new FileNotFoundException(doc + " is not found under " + parent);
		}

		LinkedList<String> path = new LinkedList<>();
		while (doc != null && FileUtils.contains(parent, doc)) {
		path.addFirst(getDocIdForFile(doc));

		doc = doc.getParentFile();
		}

		return path;
		}

		@Override
		public String createDocument(String docId, String mimeType, String displayName)
		throws FileNotFoundException {
		displayName = FileUtils.buildValidFatFilename(displayName);

		final File parent = getFileForDocId(docId);
		if (!parent.isDirectory()) {
		throw new IllegalArgumentException("Parent document isn't a directory");
		}

		final File file = FileUtils.buildUniqueFile(parent, mimeType, displayName);
		if (Document.MIME_TYPE_DIR.equals(mimeType)) {
		if (!file.mkdir()) {
		throw new IllegalStateException("Failed to mkdir " + file);
		}
		} else {
		try {
		if (!file.createNewFile()) {
		throw new IllegalStateException("Failed to touch " + file);
		}
		} catch (IOException e) {
		throw new IllegalStateException("Failed to touch " + file + ": " + e);
		}
		}

		return getDocIdForFile(file);
		}

		@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 = FileUtils.buildValidFatFilename(displayName);

		final File before = getFileForDocId(docId);
		final File after = FileUtils.buildUniqueFile(before.getParentFile(), displayName);
		final File visibleFileBefore = getFileForDocId(docId, true);
		if (!before.renameTo(after)) {
		throw new IllegalStateException("Failed to rename to " + after);
		}
		removeFromMediaStore(visibleFileBefore);

		final String afterDocId = getDocIdForFile(after);
		scanFile(getFileForDocId(afterDocId, true));

		if (!TextUtils.equals(docId, afterDocId)) {
		return afterDocId;
		} else {
		return null;
		}
		}

		@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) {
		FileUtils.deleteContents(file);
		}
		if (!file.delete()) {
		throw new IllegalStateException("Failed to delete " + file);
		}

		removeFromMediaStore(visibleFile);
		}

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

		// Notify media store to update its content
		removeFromMediaStore(visibleFileBefore);
		final String docId = getDocIdForFile(after);
		scanFile(getFileForDocId(docId, true));

		return docId;
		}

		private void removeFromMediaStore(File visibleFile) throws FileNotFoundException {
		if (visibleFile != null) {
		final ContentResolver resolver = getContext().getContentResolver();
		final Uri externalUri = MediaStore.Files.getContentUri("external");

		// Remove media store entries for any files inside this directory, using
		// path prefix match. Logic borrowed from MtpDatabase.
		if (visibleFile.isDirectory()) {
		final String path = visibleFile.getAbsolutePath() + "/";
		resolver.delete(externalUri,
		"_data LIKE ?1 AND lower(substr(_data,1,?2))=lower(?3)",
		new String[] { path + "%", Integer.toString(path.length()), path });
		}

		// Remove media store entry for this exact file.
		final String path = visibleFile.getAbsolutePath();
		resolver.delete(externalUri,
		"_data LIKE ?1 AND lower(_data)=lower(?2)",
		new String[] { path, path });
		}
		}

		@Override
		public Cursor queryDocument(String documentId, String[] projection)
		throws FileNotFoundException {
		final MatrixCursor result = new MatrixCursor(resolveProjection(projection));
		includeFile(result, documentId, null);
		return result;
		}

		@Override
		public Cursor queryChildDocuments(
		String parentDocumentId, String[] projection, String sortOrder)
		throws FileNotFoundException {

		final File parent = getFileForDocId(parentDocumentId);
		final MatrixCursor result = new DirectoryCursor(
		resolveProjection(projection), parentDocumentId, parent);
		for (File file : parent.listFiles()) {
		includeFile(result, null, file);
		}
		return result;
		}

		/**
		* Searches documents under the given folder.
		*
		* To avoid runtime explosion only returns the at most 23 items.
		*
		* @param folder the root folder where recursive search begins
		* @param query the search condition used to match file names
		* @param projection projection of the returned cursor
		* @param exclusion absolute file paths to exclude from result
		* @return cursor containing search result
		* @throws FileNotFoundException when root folder doesn't exist or search fails
		*/
		protected final Cursor querySearchDocuments(
		File folder, String query, String[] projection, Set<String> exclusion)
		throws FileNotFoundException {

		query = query.toLowerCase();
		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 (file.isDirectory()) {
		for (File child : file.listFiles()) {
		pending.add(child);
		}
		}
		if (file.getName().toLowerCase().contains(query)
		&& !exclusion.contains(file.getAbsolutePath())) {
		includeFile(result, null, file);
		}
		}
		return result;
		}

		@Override
		public String getDocumentType(String documentId) throws FileNotFoundException {
		final File file = getFileForDocId(documentId);
		return getTypeForFile(file);
		}

		@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 (pfdMode == ParcelFileDescriptor.MODE_READ_ONLY \|\| visibleFile == null) {
		return ParcelFileDescriptor.open(file, pfdMode);
		} else {
		try {
		// When finished writing, kick off media scanner
		return ParcelFileDescriptor.open(
		file, pfdMode, mHandler, (IOException e) -> scanFile(visibleFile));
		} catch (IOException e) {
		throw new FileNotFoundException("Failed to open for writing: " + e);
		}
		}
		}

		private void scanFile(File visibleFile) {
		final Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
		intent.setData(Uri.fromFile(visibleFile));
		getContext().sendBroadcast(intent);
		}

		@Override
		public AssetFileDescriptor openDocumentThumbnail(
		String documentId, Point sizeHint, CancellationSignal signal)
		throws FileNotFoundException {
		final File file = getFileForDocId(documentId);
		return DocumentsContract.openImageThumbnail(file);
		}

		protected RowBuilder includeFile(MatrixCursor result, String docId, File file)
		throws FileNotFoundException {
		if (docId == null) {
		docId = getDocIdForFile(file);
		} else {
		file = getFileForDocId(docId);
		}

		int flags = 0;

		if (file.canWrite()) {
		if (file.isDirectory()) {
		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;
		}
		}

		final String mimeType = getTypeForFile(file);
		final String displayName = file.getName();
		if (mimeType.startsWith("image/")) {
		flags \|= Document.FLAG_SUPPORTS_THUMBNAIL;
		}

		final RowBuilder row = result.newRow();
		row.add(Document.COLUMN_DOCUMENT_ID, docId);
		row.add(Document.COLUMN_DISPLAY_NAME, displayName);
		row.add(Document.COLUMN_SIZE, file.length());
		row.add(Document.COLUMN_MIME_TYPE, mimeType);
		row.add(Document.COLUMN_FLAGS, flags);

		// Only publish dates reasonably after epoch
		long lastModified = file.lastModified();
		if (lastModified > 31536000000L) {
		row.add(Document.COLUMN_LAST_MODIFIED, lastModified);
		}

		// Return the row builder just in case any subclass want to add more stuff to it.
		return row;
		}

		private static String getTypeForFile(File file) {
		if (file.isDirectory()) {
		return Document.MIME_TYPE_DIR;
		} else {
		return getTypeForName(file.getName());
		}
		}

		private static String getTypeForName(String name) {
		final int lastDot = name.lastIndexOf('.');
		if (lastDot >= 0) {
		final String extension = name.substring(lastDot + 1).toLowerCase();
		final String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
		if (mime != null) {
		return mime;
		}
		}

		return "application/octet-stream";
		}

		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) {
		synchronized (mObservers) {
		DirectoryObserver observer = mObservers.get(file);
		if (observer == null) {
		observer = new DirectoryObserver(
		file, getContext().getContentResolver(), notifyUri);
		observer.startWatching();
		mObservers.put(file, observer);
		}
		observer.mRefCount++;

		if (LOG_INOTIFY) Log.d(TAG, "after start: " + observer);
		}
		}

		private void stopObserving(File file) {
		synchronized (mObservers) {
		DirectoryObserver observer = mObservers.get(file);
		if (observer == null) return;

		observer.mRefCount--;
		if (observer.mRefCount == 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 int mRefCount = 0;

		public DirectoryObserver(File file, ContentResolver resolver, Uri notifyUri) {
		super(file.getAbsolutePath(), NOTIFY_EVENTS);
		mFile = file;
		mResolver = resolver;
		mNotifyUri = notifyUri;
		}

		@Override
		public void onEvent(int event, String path) {
		if ((event & NOTIFY_EVENTS) != 0) {
		if (LOG_INOTIFY) Log.d(TAG, "onEvent() " + event + " at " + path);
		mResolver.notifyChange(mNotifyUri, null, false);
		}
		}

		@Override
		public String toString() {
		return "DirectoryObserver{file=" + mFile.getAbsolutePath() + ", ref=" + mRefCount + "}";
		}
		}

		private class DirectoryCursor extends MatrixCursor {
		private final File mFile;

		public DirectoryCursor(String[] columnNames, String docId, File file) {
		super(columnNames);

		final Uri notifyUri = buildNotificationUri(docId);
		setNotificationUri(getContext().getContentResolver(), notifyUri);

		mFile = file;
		startObserving(mFile, notifyUri);
		}

		@Override
		public void close() {
		super.close();
		stopObserving(mFile);
		}
		}
		}

packages/ExternalStorageProvider/src/com/android/externalstorage/ExternalStorageProvider.java

+14 −368

File changed.

Preview size limit exceeded, changes collapsed.