| Methods Summary |
|---|
| private static java.io.File | buildFile(java.io.File parent, java.lang.String name, java.lang.String ext)
if (TextUtils.isEmpty(ext)) {
return new File(parent, name);
} else {
return new File(parent, name + "." + ext);
}
|
| public static java.io.File | buildUniqueFile(java.io.File parent, java.lang.String mimeType, java.lang.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 = 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;
|
| public java.lang.String | createDocument(java.lang.String docId, java.lang.String mimeType, java.lang.String displayName)
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);
|
| public void | deleteDocument(java.lang.String docId)
final File file = getFileForDocId(docId);
if (file.isDirectory()) {
FileUtils.deleteContents(file);
}
if (!file.delete()) {
throw new IllegalStateException("Failed to delete " + file);
}
|
| private java.lang.String | getDocIdForFile(java.io.File file)
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;
|
| public java.lang.String | getDocumentType(java.lang.String documentId)
final File file = getFileForDocId(documentId);
return getTypeForFile(file);
|
| private java.io.File | getFileForDocId(java.lang.String docId)
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 static java.lang.String | getTypeForFile(java.io.File file)
if (file.isDirectory()) {
return Document.MIME_TYPE_DIR;
} else {
return getTypeForName(file.getName());
}
|
| private static java.lang.String | getTypeForName(java.lang.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 | includeFile(android.database.MatrixCursor result, java.lang.String docId, java.io.File file)
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);
}
|
| public boolean | isChildDocument(java.lang.String parentDocId, java.lang.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);
}
|
| 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 android.os.ParcelFileDescriptor | openDocument(java.lang.String documentId, java.lang.String mode, android.os.CancellationSignal signal)
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);
}
}
|
| public android.content.res.AssetFileDescriptor | openDocumentThumbnail(java.lang.String documentId, android.graphics.Point sizeHint, android.os.CancellationSignal signal)
final File file = getFileForDocId(documentId);
return DocumentsContract.openImageThumbnail(file);
|
| public android.database.Cursor | queryChildDocuments(java.lang.String parentDocumentId, java.lang.String[] projection, java.lang.String 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;
|
| public android.database.Cursor | queryDocument(java.lang.String documentId, java.lang.String[] projection)
final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
includeFile(result, documentId, null);
return result;
|
| public android.database.Cursor | queryRoots(java.lang.String[] projection)
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;
|
| public android.database.Cursor | querySearchDocuments(java.lang.String rootId, java.lang.String query, java.lang.String[] projection)
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;
|
| public java.lang.String | renameDocument(java.lang.String docId, java.lang.String displayName)
// 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;
}
|
| private static java.lang.String[] | resolveDocumentProjection(java.lang.String[] projection)
return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
|
| private static java.lang.String[] | resolveRootProjection(java.lang.String[] projection)
return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
|
| private void | startObserving(java.io.File file, android.net.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(java.io.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);
}
|
| 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);
|
