| /* |
| * Copyright (C) 2013 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.externalstorage; |
| |
| 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.net.Uri; |
| import android.os.CancellationSignal; |
| import android.os.Environment; |
| import android.os.FileObserver; |
| import android.os.FileUtils; |
| import android.os.Handler; |
| import android.os.ParcelFileDescriptor; |
| import android.os.ParcelFileDescriptor.OnCloseListener; |
| import android.os.storage.StorageManager; |
| import android.os.storage.StorageVolume; |
| import android.provider.DocumentsContract; |
| import android.provider.DocumentsContract.Document; |
| import android.provider.DocumentsContract.Root; |
| import android.provider.DocumentsProvider; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.webkit.MimeTypeMap; |
| |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.google.android.collect.Lists; |
| import com.google.android.collect.Maps; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.Map; |
| import java.util.Objects; |
| |
| public class ExternalStorageProvider extends DocumentsProvider { |
| private static final String TAG = "ExternalStorage"; |
| |
| private static final boolean LOG_INOTIFY = false; |
| |
| public static final String AUTHORITY = "com.android.externalstorage.documents"; |
| |
| // docId format: root:path/to/file |
| |
| 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, Root.COLUMN_AVAILABLE_BYTES, |
| }; |
| |
| 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 static class RootInfo { |
| public String rootId; |
| public int flags; |
| public String title; |
| public String docId; |
| } |
| |
| private static final String ROOT_ID_PRIMARY_EMULATED = "primary"; |
| |
| private StorageManager mStorageManager; |
| private Handler mHandler; |
| |
| private final Object mRootsLock = new Object(); |
| |
| @GuardedBy("mRootsLock") |
| private ArrayList<RootInfo> mRoots; |
| @GuardedBy("mRootsLock") |
| private HashMap<String, RootInfo> mIdToRoot; |
| @GuardedBy("mRootsLock") |
| private HashMap<String, File> mIdToPath; |
| |
| @GuardedBy("mObservers") |
| private Map<File, DirectoryObserver> mObservers = Maps.newHashMap(); |
| |
| @Override |
| public boolean onCreate() { |
| mStorageManager = (StorageManager) getContext().getSystemService(Context.STORAGE_SERVICE); |
| mHandler = new Handler(); |
| |
| mRoots = Lists.newArrayList(); |
| mIdToRoot = Maps.newHashMap(); |
| mIdToPath = Maps.newHashMap(); |
| |
| updateVolumes(); |
| |
| return true; |
| } |
| |
| public void updateVolumes() { |
| synchronized (mRootsLock) { |
| updateVolumesLocked(); |
| } |
| } |
| |
| private void updateVolumesLocked() { |
| mRoots.clear(); |
| mIdToPath.clear(); |
| mIdToRoot.clear(); |
| |
| final StorageVolume[] volumes = mStorageManager.getVolumeList(); |
| for (StorageVolume volume : volumes) { |
| final boolean mounted = Environment.MEDIA_MOUNTED.equals(volume.getState()) |
| || Environment.MEDIA_MOUNTED_READ_ONLY.equals(volume.getState()); |
| if (!mounted) continue; |
| |
| final String rootId; |
| if (volume.isPrimary() && volume.isEmulated()) { |
| rootId = ROOT_ID_PRIMARY_EMULATED; |
| } else if (volume.getUuid() != null) { |
| rootId = volume.getUuid(); |
| } else { |
| Log.d(TAG, "Missing UUID for " + volume.getPath() + "; skipping"); |
| continue; |
| } |
| |
| if (mIdToPath.containsKey(rootId)) { |
| Log.w(TAG, "Duplicate UUID " + rootId + "; skipping"); |
| continue; |
| } |
| |
| try { |
| final File path = volume.getPathFile(); |
| mIdToPath.put(rootId, path); |
| |
| final RootInfo root = new RootInfo(); |
| root.rootId = rootId; |
| root.flags = Root.FLAG_SUPPORTS_CREATE | Root.FLAG_LOCAL_ONLY | Root.FLAG_ADVANCED |
| | Root.FLAG_SUPPORTS_SEARCH | Root.FLAG_SUPPORTS_IS_CHILD; |
| if (ROOT_ID_PRIMARY_EMULATED.equals(rootId)) { |
| root.title = getContext().getString(R.string.root_internal_storage); |
| } else { |
| final String userLabel = volume.getUserLabel(); |
| if (!TextUtils.isEmpty(userLabel)) { |
| root.title = userLabel; |
| } else { |
| root.title = volume.getDescription(getContext()); |
| } |
| } |
| root.docId = getDocIdForFile(path); |
| mRoots.add(root); |
| mIdToRoot.put(rootId, root); |
| } catch (FileNotFoundException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| |
| Log.d(TAG, "After updating volumes, found " + mRoots.size() + " active roots"); |
| |
| getContext().getContentResolver() |
| .notifyChange(DocumentsContract.buildRootsUri(AUTHORITY), null, false); |
| } |
| |
| 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; |
| } |
| |
| private String getDocIdForFile(File file) throws FileNotFoundException { |
| String path = file.getAbsolutePath(); |
| |
| // Find the most-specific root path |
| Map.Entry<String, File> mostSpecific = null; |
| synchronized (mRootsLock) { |
| for (Map.Entry<String, File> root : mIdToPath.entrySet()) { |
| final String rootPath = root.getValue().getPath(); |
| if (path.startsWith(rootPath) && (mostSpecific == null |
| || rootPath.length() > mostSpecific.getValue().getPath().length())) { |
| mostSpecific = root; |
| } |
| } |
| } |
| |
| if (mostSpecific == null) { |
| throw new FileNotFoundException("Failed to find root that contains " + path); |
| } |
| |
| // Start at first char of path under root |
| final String rootPath = mostSpecific.getValue().getPath(); |
| if (rootPath.equals(path)) { |
| path = ""; |
| } else if (rootPath.endsWith("/")) { |
| path = path.substring(rootPath.length()); |
| } else { |
| path = path.substring(rootPath.length() + 1); |
| } |
| |
| return mostSpecific.getKey() + ':' + path; |
| } |
| |
| private File getFileForDocId(String docId) throws FileNotFoundException { |
| final int splitIndex = docId.indexOf(':', 1); |
| final String tag = docId.substring(0, splitIndex); |
| final String path = docId.substring(splitIndex + 1); |
| |
| File target; |
| synchronized (mRootsLock) { |
| target = mIdToPath.get(tag); |
| } |
| if (target == null) { |
| throw new FileNotFoundException("No root for " + tag); |
| } |
| if (!target.exists()) { |
| target.mkdirs(); |
| } |
| target = new File(target, path); |
| if (!target.exists()) { |
| throw new FileNotFoundException("Missing file for " + docId + " at " + target); |
| } |
| return target; |
| } |
| |
| private void 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; |
| } else { |
| flags |= Document.FLAG_SUPPORTS_WRITE; |
| flags |= Document.FLAG_SUPPORTS_DELETE; |
| flags |= Document.FLAG_SUPPORTS_RENAME; |
| } |
| } |
| |
| final String displayName = file.getName(); |
| final String mimeType = getTypeForFile(file); |
| 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); |
| } |
| } |
| |
| @Override |
| public Cursor queryRoots(String[] projection) throws FileNotFoundException { |
| final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection)); |
| synchronized (mRootsLock) { |
| for (String rootId : mIdToPath.keySet()) { |
| final RootInfo root = mIdToRoot.get(rootId); |
| final File path = mIdToPath.get(rootId); |
| |
| final RowBuilder row = result.newRow(); |
| row.add(Root.COLUMN_ROOT_ID, root.rootId); |
| row.add(Root.COLUMN_FLAGS, root.flags); |
| row.add(Root.COLUMN_TITLE, root.title); |
| row.add(Root.COLUMN_DOCUMENT_ID, root.docId); |
| row.add(Root.COLUMN_AVAILABLE_BYTES, path.getFreeSpace()); |
| } |
| } |
| return result; |
| } |
| |
| @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); |
| } |
| } |
| |
| @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 = 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); |
| } |
| |
| 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); |
| } |
| } |
| |
| @VisibleForTesting |
| public static File buildUniqueFile(File parent, String mimeType, String displayName) |
| throws FileNotFoundException { |
| 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 = 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; |
| } |
| } |
| |
| 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; |
| } |
| |
| @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 = new File(before.getParentFile(), displayName); |
| if (after.exists()) { |
| throw new IllegalStateException("Already exists " + after); |
| } |
| if (!before.renameTo(after)) { |
| throw new IllegalStateException("Failed to rename to " + after); |
| } |
| final String afterDocId = getDocIdForFile(after); |
| if (!TextUtils.equals(docId, afterDocId)) { |
| return afterDocId; |
| } else { |
| return null; |
| } |
| } |
| |
| @Override |
| public void deleteDocument(String docId) throws FileNotFoundException { |
| final File file = getFileForDocId(docId); |
| if (file.isDirectory()) { |
| FileUtils.deleteContents(file); |
| } |
| if (!file.delete()) { |
| throw new IllegalStateException("Failed to delete " + file); |
| } |
| } |
| |
| @Override |
| public Cursor queryDocument(String documentId, String[] projection) |
| throws FileNotFoundException { |
| final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(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( |
| resolveDocumentProjection(projection), parentDocumentId, parent); |
| for (File file : parent.listFiles()) { |
| includeFile(result, null, file); |
| } |
| return result; |
| } |
| |
| @Override |
| public Cursor querySearchDocuments(String rootId, String query, String[] projection) |
| throws FileNotFoundException { |
| final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection)); |
| |
| final File parent; |
| synchronized (mRootsLock) { |
| parent = mIdToPath.get(rootId); |
| } |
| |
| final LinkedList<File> pending = new LinkedList<File>(); |
| pending.add(parent); |
| 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)) { |
| 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 int pfdMode = ParcelFileDescriptor.parseMode(mode); |
| if (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, new OnCloseListener() { |
| @Override |
| public void onClose(IOException e) { |
| final Intent intent = new Intent( |
| Intent.ACTION_MEDIA_SCANNER_SCAN_FILE); |
| intent.setData(Uri.fromFile(file)); |
| getContext().sendBroadcast(intent); |
| } |
| }); |
| } catch (IOException e) { |
| throw new FileNotFoundException("Failed to open for writing: " + e); |
| } |
| } |
| } |
| |
| @Override |
| public AssetFileDescriptor openDocumentThumbnail( |
| String documentId, Point sizeHint, CancellationSignal signal) |
| throws FileNotFoundException { |
| final File file = getFileForDocId(documentId); |
| return DocumentsContract.openImageThumbnail(file); |
| } |
| |
| 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"; |
| } |
| |
| 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 = DocumentsContract.buildChildDocumentsUri( |
| AUTHORITY, docId); |
| setNotificationUri(getContext().getContentResolver(), notifyUri); |
| |
| mFile = file; |
| startObserving(mFile, notifyUri); |
| } |
| |
| @Override |
| public void close() { |
| super.close(); |
| stopObserving(mFile); |
| } |
| } |
| } |