| /* |
| * 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.Bundle; |
| 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.UserHandle; |
| import android.os.storage.StorageManager; |
| import android.os.storage.VolumeInfo; |
| import android.provider.DocumentsContract; |
| import android.provider.DocumentsContract.Document; |
| import android.provider.DocumentsContract.Root; |
| import android.provider.DocumentsProvider; |
| import android.provider.MediaStore; |
| import android.support.provider.DocumentArchiveHelper; |
| import android.text.TextUtils; |
| import android.util.ArrayMap; |
| import android.util.DebugUtils; |
| import android.util.Log; |
| import android.webkit.MimeTypeMap; |
| |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.util.IndentingPrintWriter; |
| |
| import java.io.File; |
| import java.io.FileDescriptor; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| 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"; |
| |
| private static final Uri BASE_URI = |
| new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).authority(AUTHORITY).build(); |
| |
| // 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; |
| public File visiblePath; |
| public File path; |
| public boolean reportAvailableBytes = true; |
| } |
| |
| private static final String ROOT_ID_PRIMARY_EMULATED = "primary"; |
| private static final String ROOT_ID_HOME = "home"; |
| |
| private StorageManager mStorageManager; |
| private Handler mHandler; |
| private DocumentArchiveHelper mArchiveHelper; |
| |
| private final Object mRootsLock = new Object(); |
| |
| @GuardedBy("mRootsLock") |
| private ArrayMap<String, RootInfo> mRoots = new ArrayMap<>(); |
| |
| @GuardedBy("mObservers") |
| private ArrayMap<File, DirectoryObserver> mObservers = new ArrayMap<>(); |
| |
| @Override |
| public boolean onCreate() { |
| mStorageManager = (StorageManager) getContext().getSystemService(Context.STORAGE_SERVICE); |
| mHandler = new Handler(); |
| mArchiveHelper = new DocumentArchiveHelper(this, (char) 0); |
| |
| updateVolumes(); |
| return true; |
| } |
| |
| public void updateVolumes() { |
| synchronized (mRootsLock) { |
| updateVolumesLocked(); |
| } |
| } |
| |
| private void updateVolumesLocked() { |
| mRoots.clear(); |
| |
| VolumeInfo primaryVolume = null; |
| final int userId = UserHandle.myUserId(); |
| final List<VolumeInfo> volumes = mStorageManager.getVolumes(); |
| for (VolumeInfo volume : volumes) { |
| if (!volume.isMountedReadable()) continue; |
| |
| final String rootId; |
| final String title; |
| if (volume.getType() == VolumeInfo.TYPE_EMULATED) { |
| // We currently only support a single emulated volume mounted at |
| // a time, and it's always considered the primary |
| rootId = ROOT_ID_PRIMARY_EMULATED; |
| if (VolumeInfo.ID_EMULATED_INTERNAL.equals(volume.getId())) { |
| title = getContext().getString(R.string.root_internal_storage); |
| } else { |
| final VolumeInfo privateVol = mStorageManager.findPrivateForEmulated(volume); |
| title = mStorageManager.getBestVolumeDescription(privateVol); |
| } |
| } else if (volume.getType() == VolumeInfo.TYPE_PUBLIC) { |
| rootId = volume.getFsUuid(); |
| title = mStorageManager.getBestVolumeDescription(volume); |
| } else { |
| // Unsupported volume; ignore |
| continue; |
| } |
| |
| if (TextUtils.isEmpty(rootId)) { |
| Log.d(TAG, "Missing UUID for " + volume.getId() + "; skipping"); |
| continue; |
| } |
| if (mRoots.containsKey(rootId)) { |
| Log.w(TAG, "Duplicate UUID " + rootId + " for " + volume.getId() + "; skipping"); |
| continue; |
| } |
| |
| final RootInfo root = new RootInfo(); |
| mRoots.put(rootId, root); |
| |
| root.rootId = rootId; |
| root.flags = Root.FLAG_LOCAL_ONLY |
| | Root.FLAG_SUPPORTS_SEARCH | Root.FLAG_SUPPORTS_IS_CHILD; |
| |
| if (volume.isPrimary()) { |
| // save off the primary volume for subsequent "Home" dir initialization. |
| primaryVolume = volume; |
| root.flags |= Root.FLAG_ADVANCED; |
| } |
| // Dunno when this would NOT be the case, but never hurts to be correct. |
| if (volume.isMountedWritable()) { |
| root.flags |= Root.FLAG_SUPPORTS_CREATE; |
| } |
| root.title = title; |
| if (volume.getType() == VolumeInfo.TYPE_PUBLIC) { |
| root.flags |= Root.FLAG_HAS_SETTINGS; |
| } |
| if (volume.isVisibleForRead(userId)) { |
| root.visiblePath = volume.getPathForUser(userId); |
| } else { |
| root.visiblePath = null; |
| } |
| root.path = volume.getInternalPathForUser(userId); |
| try { |
| root.docId = getDocIdForFile(root.path); |
| } catch (FileNotFoundException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| |
| // Finally, if primary storage is available we add the "Home" directory, |
| // creating it as needed. |
| if (primaryVolume != null && primaryVolume.isVisible()) { |
| final RootInfo root = new RootInfo(); |
| root.rootId = ROOT_ID_HOME; |
| mRoots.put(root.rootId, root); |
| root.title = getContext().getString(R.string.root_home); |
| |
| // Only report bytes on *volumes*...as a matter of policy. |
| root.reportAvailableBytes = false; |
| root.flags = Root.FLAG_LOCAL_ONLY | Root.FLAG_SUPPORTS_SEARCH |
| | Root.FLAG_SUPPORTS_IS_CHILD; |
| |
| // Dunno when this would NOT be the case, but never hurts to be correct. |
| if (primaryVolume.isMountedWritable()) { |
| root.flags |= Root.FLAG_SUPPORTS_CREATE; |
| } |
| |
| // Create the "Home" directory on disk, but don't the localized root.title |
| // since the directories shouldn't be localized. |
| root.visiblePath = new File( |
| primaryVolume.getPathForUser(userId), Environment.DIRECTORY_HOME); |
| root.path = new File( |
| primaryVolume.getInternalPathForUser(userId), root.rootId); |
| try { |
| root.docId = getDocIdForFile(root.path); |
| } catch (FileNotFoundException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| |
| Log.d(TAG, "After updating volumes, found " + mRoots.size() + " active roots"); |
| |
| // Note this affects content://com.android.externalstorage.documents/root/39BD-07C5 |
| // as well as content://com.android.externalstorage.documents/document/*/children, |
| // so just notify on content://com.android.externalstorage.documents/. |
| getContext().getContentResolver().notifyChange(BASE_URI, 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 { |
| return getDocIdForFileMaybeCreate(file, false); |
| } |
| |
| private String getDocIdForFileMaybeCreate(File file, boolean createNewDir) |
| throws FileNotFoundException { |
| String path = file.getAbsolutePath(); |
| |
| // Find the most-specific root path |
| String mostSpecificId = null; |
| String mostSpecificPath = null; |
| synchronized (mRootsLock) { |
| for (int i = 0; i < mRoots.size(); i++) { |
| final String rootId = mRoots.keyAt(i); |
| final String rootPath = mRoots.valueAt(i).path.getAbsolutePath(); |
| if (path.startsWith(rootPath) && (mostSpecificPath == null |
| || rootPath.length() > mostSpecificPath.length())) { |
| mostSpecificId = rootId; |
| mostSpecificPath = rootPath; |
| } |
| } |
| } |
| |
| if (mostSpecificPath == null) { |
| throw new FileNotFoundException("Failed to find root that contains " + path); |
| } |
| |
| // Start at first char of path under root |
| final String rootPath = mostSpecificPath; |
| if (rootPath.equals(path)) { |
| path = ""; |
| } else if (rootPath.endsWith("/")) { |
| path = path.substring(rootPath.length()); |
| } else { |
| path = path.substring(rootPath.length() + 1); |
| } |
| |
| if (!file.exists() && createNewDir) { |
| Log.i(TAG, "Creating new directory " + file); |
| if (!file.mkdir()) { |
| Log.e(TAG, "Could not create directory " + file); |
| } |
| } |
| |
| return mostSpecificId + ':' + path; |
| } |
| |
| private File getFileForDocId(String docId) throws FileNotFoundException { |
| return getFileForDocId(docId, false); |
| } |
| |
| private File getFileForDocId(String docId, boolean visible) throws FileNotFoundException { |
| final int splitIndex = docId.indexOf(':', 1); |
| final String tag = docId.substring(0, splitIndex); |
| final String path = docId.substring(splitIndex + 1); |
| |
| RootInfo root; |
| synchronized (mRootsLock) { |
| root = mRoots.get(tag); |
| } |
| if (root == null) { |
| throw new FileNotFoundException("No root for " + tag); |
| } |
| |
| File target = visible ? root.visiblePath : root.path; |
| if (target == null) { |
| return null; |
| } |
| 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; |
| 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); |
| if (mArchiveHelper.isSupportedArchiveType(mimeType)) { |
| flags |= Document.FLAG_ARCHIVE; |
| } |
| |
| 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); |
| row.add(DocumentArchiveHelper.COLUMN_LOCAL_FILE_PATH, file.getPath()); |
| |
| // 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 (RootInfo root : mRoots.values()) { |
| 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, |
| root.reportAvailableBytes ? root.path.getFreeSpace() : -1); |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| public boolean isChildDocument(String parentDocId, String docId) { |
| try { |
| if (mArchiveHelper.isArchivedDocument(docId)) { |
| return mArchiveHelper.isChildDocument(parentDocId, docId); |
| } |
| |
| 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 = 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 = 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); |
| final boolean isDirectory = file.isDirectory(); |
| if (isDirectory) { |
| FileUtils.deleteContents(file); |
| } |
| if (!file.delete()) { |
| throw new IllegalStateException("Failed to delete " + file); |
| } |
| |
| 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 (isDirectory) { |
| final String path = file.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 = file.getAbsolutePath(); |
| resolver.delete(externalUri, |
| "_data LIKE ?1 AND lower(_data)=lower(?2)", |
| new String[] { path, path }); |
| } |
| |
| @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()); |
| |
| if (after.exists()) { |
| throw new IllegalStateException("Already exists " + after); |
| } |
| if (!before.renameTo(after)) { |
| throw new IllegalStateException("Failed to move to " + after); |
| } |
| return getDocIdForFile(after); |
| } |
| |
| @Override |
| public Cursor queryDocument(String documentId, String[] projection) |
| throws FileNotFoundException { |
| if (mArchiveHelper.isArchivedDocument(documentId)) { |
| return mArchiveHelper.queryDocument(documentId, projection); |
| } |
| |
| 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 { |
| if (mArchiveHelper.isArchivedDocument(parentDocumentId) || |
| mArchiveHelper.isSupportedArchiveType(getDocumentType(parentDocumentId))) { |
| return mArchiveHelper.queryChildDocuments(parentDocumentId, projection, sortOrder); |
| } |
| |
| 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 = mRoots.get(rootId).path; |
| } |
| |
| 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 { |
| if (mArchiveHelper.isArchivedDocument(documentId)) { |
| return mArchiveHelper.getDocumentType(documentId); |
| } |
| |
| final File file = getFileForDocId(documentId); |
| return getTypeForFile(file); |
| } |
| |
| @Override |
| public ParcelFileDescriptor openDocument( |
| String documentId, String mode, CancellationSignal signal) |
| throws FileNotFoundException { |
| if (mArchiveHelper.isArchivedDocument(documentId)) { |
| return mArchiveHelper.openDocument(documentId, mode, signal); |
| } |
| |
| 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, new OnCloseListener() { |
| @Override |
| public void onClose(IOException e) { |
| final Intent intent = new Intent( |
| Intent.ACTION_MEDIA_SCANNER_SCAN_FILE); |
| intent.setData(Uri.fromFile(visibleFile)); |
| 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 { |
| if (mArchiveHelper.isArchivedDocument(documentId)) { |
| return mArchiveHelper.openDocumentThumbnail(documentId, sizeHint, signal); |
| } |
| |
| final File file = getFileForDocId(documentId); |
| return DocumentsContract.openImageThumbnail(file); |
| } |
| |
| @Override |
| public void dump(FileDescriptor fd, PrintWriter writer, String[] args) { |
| final IndentingPrintWriter pw = new IndentingPrintWriter(writer, " ", 160); |
| synchronized (mRootsLock) { |
| for (int i = 0; i < mRoots.size(); i++) { |
| final RootInfo root = mRoots.valueAt(i); |
| pw.println("Root{" + root.rootId + "}:"); |
| pw.increaseIndent(); |
| pw.printPair("flags", DebugUtils.flagsToString(Root.class, "FLAG_", root.flags)); |
| pw.println(); |
| pw.printPair("title", root.title); |
| pw.printPair("docId", root.docId); |
| pw.println(); |
| pw.printPair("path", root.path); |
| pw.printPair("visiblePath", root.visiblePath); |
| pw.decreaseIndent(); |
| pw.println(); |
| } |
| } |
| } |
| |
| @Override |
| public Bundle call(String method, String arg, Bundle extras) { |
| Bundle bundle = super.call(method, arg, extras); |
| if (bundle == null && !TextUtils.isEmpty(method)) { |
| switch (method) { |
| case "getDocIdForFileCreateNewDir": { |
| getContext().enforceCallingPermission( |
| android.Manifest.permission.MANAGE_DOCUMENTS, null); |
| if (TextUtils.isEmpty(arg)) { |
| return null; |
| } |
| try { |
| final String docId = getDocIdForFileMaybeCreate(new File(arg), true); |
| bundle = new Bundle(); |
| bundle.putString("DOC_ID", docId); |
| } catch (FileNotFoundException e) { |
| Log.w(TAG, "file '" + arg + "' not found"); |
| return null; |
| } |
| break; |
| } |
| default: |
| Log.w(TAG, "unknown method passed to call(): " + method); |
| } |
| } |
| return bundle; |
| } |
| |
| 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); |
| } |
| } |
| } |