src/com/android/documentsui/services/CopyJob.java - platform/packages/apps/DocumentsUI - Gitiles

 /*
  * Copyright (C) 2016 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.documentsui.services;

 import static android.os.SystemClock.elapsedRealtime;
 import static com.android.documentsui.DocumentsApplication.acquireUnstableProviderOrThrow;
 import static com.android.documentsui.Shared.DEBUG;
 import static com.android.documentsui.model.DocumentInfo.getCursorLong;
 import static com.android.documentsui.model.DocumentInfo.getCursorString;
 import static com.android.documentsui.services.FileOperationService.OPERATION_COPY;
 import static com.google.common.base.Preconditions.checkArgument;

 import android.annotation.StringRes;
 import android.app.Notification;
 import android.app.Notification.Builder;
 import android.content.ContentProviderClient;
 import android.content.Context;
 import android.content.res.AssetFileDescriptor;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.CancellationSignal;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.provider.DocumentsContract;
 import android.provider.DocumentsContract.Document;
 import android.text.format.DateUtils;
 import android.util.Log;
 import android.webkit.MimeTypeMap;

 import com.android.documentsui.R;
 import com.android.documentsui.model.DocumentInfo;
 import com.android.documentsui.model.DocumentStack;

 import libcore.io.IoUtils;

 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.text.NumberFormat;
 import java.util.List;

 class CopyJob extends Job {
     private static final String TAG = "CopyJob";
     private static final int PROGRESS_INTERVAL_MILLIS = 1000;
     final List<DocumentInfo> mSrcFiles;

     // Provider clients are acquired for the duration of each copy job. Note that there is an
     // implicit assumption that all srcs come from the same authority.
     ContentProviderClient srcClient;
     ContentProviderClient dstClient;

     private long mStartTime = -1;
     private long mBatchSize;
     private long mBytesCopied;
     private long mLastNotificationTime;
     // Speed estimation
     private long mBytesCopiedSample;
     private long mSampleTime;
     private long mSpeed;
     private long mRemainingTime;

     /**
      * Copies files to a destination identified by {@code destination}.
      * @see @link {@link Job} constructor for most param descriptions.
      *
      * @param srcs List of files to be copied.
      */
     CopyJob(Context serviceContext, Context appContext, Listener listener,
             String id, DocumentStack destination, List<DocumentInfo> srcs) {
         super(OPERATION_COPY, serviceContext, appContext, listener, id, destination);

         checkArgument(!srcs.isEmpty());
         this.mSrcFiles = srcs;
     }

     @Override
     Builder createProgressBuilder() {
         return super.createProgressBuilder(
                 serviceContext.getString(R.string.copy_notification_title),
                 R.drawable.ic_menu_copy,
                 serviceContext.getString(android.R.string.cancel),
                 R.drawable.ic_cab_cancel);
     }

     @Override
     public Notification getSetupNotification() {
         return getSetupNotification(serviceContext.getString(R.string.copy_preparing));
     }

     public boolean shouldUpdateProgress() {
         // Wait a while between updates :)
         return elapsedRealtime() - mLastNotificationTime > PROGRESS_INTERVAL_MILLIS;
     }

     Notification getProgressNotification(@StringRes int msgId) {
         double completed = (double) this.mBytesCopied / mBatchSize;
         mProgressBuilder.setProgress(100, (int) (completed * 100), false);
         mProgressBuilder.setContentInfo(
                 NumberFormat.getPercentInstance().format(completed));
         if (mRemainingTime > 0) {
             mProgressBuilder.setContentText(serviceContext.getString(msgId,
                     DateUtils.formatDuration(mRemainingTime)));
         } else {
             mProgressBuilder.setContentText(null);
         }

         // Remember when we last returned progress so we can provide an answer
         // in shouldUpdateProgress.
         mLastNotificationTime = elapsedRealtime();
         return mProgressBuilder.build();
     }

     public Notification getProgressNotification() {
         return getProgressNotification(R.string.copy_remaining);
     }

     void onBytesCopied(long numBytes) {
         this.mBytesCopied += numBytes;
     }

     /**
      * Generates an estimate of the remaining time in the copy.
      */
     void updateRemainingTimeEstimate() {
         long elapsedTime = elapsedRealtime() - mStartTime;

         final long sampleDuration = elapsedTime - mSampleTime;
         final long sampleSpeed = ((mBytesCopied - mBytesCopiedSample) * 1000) / sampleDuration;
         if (mSpeed == 0) {
             mSpeed = sampleSpeed;
         } else {
             mSpeed = ((3 * mSpeed) + sampleSpeed) / 4;
         }

         if (mSampleTime > 0 && mSpeed > 0) {
             mRemainingTime = ((mBatchSize - mBytesCopied) * 1000) / mSpeed;
         } else {
             mRemainingTime = 0;
         }

         mSampleTime = elapsedTime;
         mBytesCopiedSample = mBytesCopied;
     }

     @Override
     Notification getFailureNotification() {
         return getFailureNotification(
                 R.plurals.copy_error_notification_title, R.drawable.ic_menu_copy);
     }

     @Override
     void run(FileOperationService service) throws RemoteException {
         mStartTime = elapsedRealtime();

         // Acquire content providers.
         srcClient = acquireUnstableProviderOrThrow(
                 getContentResolver(),
                 mSrcFiles.get(0).authority);
         dstClient = acquireUnstableProviderOrThrow(
                 getContentResolver(),
                 stack.peek().authority);

         // client
         mBatchSize = calculateSize(srcClient, mSrcFiles);

         DocumentInfo srcInfo;
         DocumentInfo dstInfo;
         for (int i = 0; i < mSrcFiles.size() && !isCanceled(); ++i) {
             srcInfo = mSrcFiles.get(i);
             dstInfo = stack.peek();

             // Guard unsupported recursive operation.
             if (dstInfo.equals(srcInfo) || isDescendentOf(srcInfo, dstInfo)) {
                 if (DEBUG) Log.d(TAG, "Skipping recursive operation on directory "
                         + dstInfo.derivedUri);
                 onFileFailed(srcInfo);
                 continue;
             }

             if (DEBUG) Log.d(TAG,
                     "Performing op-type:" + type() + " of " + srcInfo.displayName
                     + " (" + srcInfo.derivedUri + ")" + " to " + dstInfo.displayName
                     + " (" + dstInfo.derivedUri + ")");

             processDocument(srcInfo, dstInfo);
         }
     }

     /**
      * Logs progress on the current copy operation. Displays/Updates the progress notification.
      *
      * @param bytesCopied
      */
     private void makeCopyProgress(long bytesCopied) {
         onBytesCopied(bytesCopied);
         if (shouldUpdateProgress()) {
             updateRemainingTimeEstimate();
             listener.onProgress(this);
         }
     }

     /**
      * Copies a the given document to the given location.
      *
      * @param srcInfo DocumentInfos for the documents to copy.
      * @param dstDirInfo The destination directory.
      * @param mode The transfer mode (copy or move).
      * @return True on success, false on failure.
      * @throws RemoteException
      */
     boolean processDocument(DocumentInfo srcInfo, DocumentInfo dstDirInfo) throws RemoteException {

         // TODO: When optimized copy kicks in, we'll not making any progress updates.
         // For now. Local storage isn't using optimized copy.

         // When copying within the same provider, try to use optimized copying and moving.
         // If not supported, then fallback to byte-by-byte copy/move.
         if (srcInfo.authority.equals(dstDirInfo.authority)) {
             if ((srcInfo.flags & Document.FLAG_SUPPORTS_COPY) != 0) {
                 if (DocumentsContract.copyDocument(srcClient, srcInfo.derivedUri,
                         dstDirInfo.derivedUri) == null) {
                     onFileFailed(srcInfo);
                 }
                 return false;
             }
         }

         // If we couldn't do an optimized copy...we fall back to vanilla byte copy.
         return byteCopyDocument(srcInfo, dstDirInfo);
     }

     boolean byteCopyDocument(DocumentInfo srcInfo, DocumentInfo dstDirInfo)
             throws RemoteException {
         final String dstMimeType;
         final String dstDisplayName;

         // If the file is virtual, but can be converted to another format, then try to copy it
         // as such format. Also, append an extension for the target mime type (if known).
         if (srcInfo.isVirtualDocument()) {
             final String[] streamTypes = getContentResolver().getStreamTypes(
                     srcInfo.derivedUri, "*/*");
             if (streamTypes != null && streamTypes.length > 0) {
                 dstMimeType = streamTypes[0];
                 final String extension = MimeTypeMap.getSingleton().
                         getExtensionFromMimeType(dstMimeType);
                 dstDisplayName = srcInfo.displayName +
                         (extension != null ? "." + extension : srcInfo.displayName);
             } else {
                 // The virtual file is not available as any alternative streamable format.
                 // TODO: Log failures.
                 onFileFailed(srcInfo);
                 return false;
             }
         } else {
             dstMimeType = srcInfo.mimeType;
             dstDisplayName = srcInfo.displayName;
         }

         // Create the target document (either a file or a directory), then copy recursively the
         // contents (bytes or children).
         final Uri dstUri = DocumentsContract.createDocument(dstClient,
                 dstDirInfo.derivedUri, dstMimeType, dstDisplayName);
         if (dstUri == null) {
             // If this is a directory, the entire subdir will not be copied over.
             onFileFailed(srcInfo);
             return false;
         }

         DocumentInfo dstInfo = null;
         try {
             dstInfo = DocumentInfo.fromUri(getContentResolver(), dstUri);
         } catch (FileNotFoundException e) {
             onFileFailed(srcInfo);
             return false;
         }

         final boolean success;
         if (Document.MIME_TYPE_DIR.equals(srcInfo.mimeType)) {
             success = copyDirectoryHelper(srcInfo, dstInfo);
         } else {
             success = copyFileHelper(srcInfo, dstInfo, dstMimeType);
         }

         return success;
     }

     /**
      * Handles recursion into a directory and copying its contents. Note that in linux terms, this
      * does the equivalent of "cp src/* dst", not "cp -r src dst".
      *
      * @param srcDirInfo Info of the directory to copy from. The routine will copy the directory's
      *            contents, not the directory itself.
      * @param dstDirInfo Info of the directory to copy to. Must be created beforehand.
      * @return True on success, false if some of the children failed to copy.
      * @throws RemoteException
      */
     private boolean copyDirectoryHelper(DocumentInfo srcDirInfo, DocumentInfo dstDirInfo)
             throws RemoteException {
         // Recurse into directories. Copy children into the new subdirectory.
         final String queryColumns[] = new String[] {
                 Document.COLUMN_DISPLAY_NAME,
                 Document.COLUMN_DOCUMENT_ID,
                 Document.COLUMN_MIME_TYPE,
                 Document.COLUMN_SIZE,
                 Document.COLUMN_FLAGS
         };
         Cursor cursor = null;
         boolean success = true;
         try {
             // Iterate over srcs in the directory; copy to the destination directory.
             final Uri queryUri = DocumentsContract.buildChildDocumentsUri(srcDirInfo.authority,
                     srcDirInfo.documentId);
             cursor = srcClient.query(queryUri, queryColumns, null, null, null);
             DocumentInfo srcInfo;
             while (cursor.moveToNext()) {
                 srcInfo = DocumentInfo.fromCursor(cursor, srcDirInfo.authority);
                 success &= processDocument(srcInfo, dstDirInfo);
             }
         } finally {
             IoUtils.closeQuietly(cursor);
         }

         return success;
     }

     /**
      * Handles copying a single file.
      *
      * @param srcUriInfo Info of the file to copy from.
      * @param dstUriInfo Info of the *file* to copy to. Must be created beforehand.
      * @param mimeType Mime type for the target. Can be different than source for virtual files.
      * @return True on success, false on error.
      * @throws RemoteException
      */
     private boolean copyFileHelper(DocumentInfo srcInfo, DocumentInfo dstInfo, String mimeType)
             throws RemoteException {
         // Copy an individual file.
         CancellationSignal canceller = new CancellationSignal();
         ParcelFileDescriptor srcFile = null;
         ParcelFileDescriptor dstFile = null;
         InputStream src = null;
         OutputStream dst = null;

         boolean success = true;
         try {
             // If the file is virtual, but can be converted to another format, then try to copy it
             // as such format.
             if (srcInfo.isVirtualDocument()) {
                 final AssetFileDescriptor srcFileAsAsset =
                         srcClient.openTypedAssetFileDescriptor(
                                 srcInfo.derivedUri, mimeType, null, canceller);
                 srcFile = srcFileAsAsset.getParcelFileDescriptor();
                 src = new AssetFileDescriptor.AutoCloseInputStream(srcFileAsAsset);
             } else {
                 srcFile = srcClient.openFile(srcInfo.derivedUri, "r", canceller);
                 src = new ParcelFileDescriptor.AutoCloseInputStream(srcFile);
             }

             dstFile = dstClient.openFile(dstInfo.derivedUri, "w", canceller);
             dst = new ParcelFileDescriptor.AutoCloseOutputStream(dstFile);

             byte[] buffer = new byte[8192];
             int len;
             while ((len = src.read(buffer)) != -1) {
                 if (isCanceled()) {
                     if (DEBUG) Log.d(TAG, "Canceled copy mid-copy. Id:" + id);
                     success = false;
                     break;
                 }
                 dst.write(buffer, 0, len);
                 makeCopyProgress(len);
             }

             srcFile.checkError();
         } catch (IOException e) {
             success = false;
             onFileFailed(srcInfo);

             if (dstFile != null) {
                 try {
                     dstFile.closeWithError(e.getMessage());
                 } catch (IOException closeError) {
                     Log.e(TAG, "Error closing destination", closeError);
                 }
             }
         } finally {
             // This also ensures the file descriptors are closed.
             IoUtils.closeQuietly(src);
             IoUtils.closeQuietly(dst);
         }

         if (!success) {
             // Clean up half-copied files.
             canceller.cancel();
             try {
                 DocumentsContract.deleteDocument(dstClient, dstInfo.derivedUri);
             } catch (RemoteException e) {
                 // RemoteExceptions usually signal that the connection is dead, so there's no
                 // point attempting to continue. Propagate the exception up so the copy job is
                 // cancelled.
                 Log.w(TAG, "Failed to cleanup after copy error: " + srcInfo.derivedUri, e);
                 throw e;
             }
         }

         return success;
     }

     /**
      * Calculates the cumulative size of all the documents in the list. Directories are recursed
      * into and totaled up.
      *
      * @param srcs
      * @return Size in bytes.
      * @throws RemoteException
      */
     private static long calculateSize(ContentProviderClient client, List<DocumentInfo> srcs)
             throws RemoteException {
         long result = 0;

         for (DocumentInfo src : srcs) {
             if (src.isDirectory()) {
                 // Directories need to be recursed into.
                 result += calculateFileSizesRecursively(client, src.derivedUri);
             } else {
                 result += src.size;
             }
         }
         return result;
     }

     /**
      * Calculates (recursively) the cumulative size of all the files under the given directory.
      *
      * @throws RemoteException
      */
     private static long calculateFileSizesRecursively(
             ContentProviderClient client, Uri uri) throws RemoteException {
         final String authority = uri.getAuthority();
         final Uri queryUri = DocumentsContract.buildChildDocumentsUri(authority,
                 DocumentsContract.getDocumentId(uri));
         final String queryColumns[] = new String[] {
                 Document.COLUMN_DOCUMENT_ID,
                 Document.COLUMN_MIME_TYPE,
                 Document.COLUMN_SIZE
         };

         long result = 0;
         Cursor cursor = null;
         try {
             cursor = client.query(queryUri, queryColumns, null, null, null);
             while (cursor.moveToNext()) {
                 if (Document.MIME_TYPE_DIR.equals(
                         getCursorString(cursor, Document.COLUMN_MIME_TYPE))) {
                     // Recurse into directories.
                     final Uri dirUri = DocumentsContract.buildDocumentUri(authority,
                             getCursorString(cursor, Document.COLUMN_DOCUMENT_ID));
                     result += calculateFileSizesRecursively(client, dirUri);
                 } else {
                     // This may return -1 if the size isn't defined. Ignore those cases.
                     long size = getCursorLong(cursor, Document.COLUMN_SIZE);
                     result += size > 0 ? size : 0;
                 }
             }
         } finally {
             IoUtils.closeQuietly(cursor);
         }

         return result;
     }

     @Override
     void cleanup() {
         ContentProviderClient.releaseQuietly(srcClient);
         ContentProviderClient.releaseQuietly(dstClient);
     }

     /**
      * Returns true if {@code doc} is a descendant of {@code parentDoc}.
      * @throws RemoteException
      */
     boolean isDescendentOf(DocumentInfo doc, DocumentInfo parentDoc)
             throws RemoteException {
         if (parentDoc.isDirectory() && doc.authority.equals(parentDoc.authority)) {
             return DocumentsContract.isChildDocument(
                     dstClient, doc.derivedUri, parentDoc.derivedUri);
         }
         return false;
     }
 }
	/*
	* Copyright (C) 2016 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.documentsui.services;

	import static android.os.SystemClock.elapsedRealtime;
	import static com.android.documentsui.DocumentsApplication.acquireUnstableProviderOrThrow;
	import static com.android.documentsui.Shared.DEBUG;
	import static com.android.documentsui.model.DocumentInfo.getCursorLong;
	import static com.android.documentsui.model.DocumentInfo.getCursorString;
	import static com.android.documentsui.services.FileOperationService.OPERATION_COPY;
	import static com.google.common.base.Preconditions.checkArgument;

	import android.annotation.StringRes;
	import android.app.Notification;
	import android.app.Notification.Builder;
	import android.content.ContentProviderClient;
	import android.content.Context;
	import android.content.res.AssetFileDescriptor;
	import android.database.Cursor;
	import android.net.Uri;
	import android.os.CancellationSignal;
	import android.os.ParcelFileDescriptor;
	import android.os.RemoteException;
	import android.provider.DocumentsContract;
	import android.provider.DocumentsContract.Document;
	import android.text.format.DateUtils;
	import android.util.Log;
	import android.webkit.MimeTypeMap;

	import com.android.documentsui.R;
	import com.android.documentsui.model.DocumentInfo;
	import com.android.documentsui.model.DocumentStack;

	import libcore.io.IoUtils;

	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.text.NumberFormat;
	import java.util.List;

	class CopyJob extends Job {
	private static final String TAG = "CopyJob";
	private static final int PROGRESS_INTERVAL_MILLIS = 1000;
	final List<DocumentInfo> mSrcFiles;

	// Provider clients are acquired for the duration of each copy job. Note that there is an
	// implicit assumption that all srcs come from the same authority.
	ContentProviderClient srcClient;
	ContentProviderClient dstClient;

	private long mStartTime = -1;
	private long mBatchSize;
	private long mBytesCopied;
	private long mLastNotificationTime;
	// Speed estimation
	private long mBytesCopiedSample;
	private long mSampleTime;
	private long mSpeed;
	private long mRemainingTime;

	/**
	* Copies files to a destination identified by {@code destination}.
	* @see @link {@link Job} constructor for most param descriptions.
	*
	* @param srcs List of files to be copied.
	*/
	CopyJob(Context serviceContext, Context appContext, Listener listener,
	String id, DocumentStack destination, List<DocumentInfo> srcs) {
	super(OPERATION_COPY, serviceContext, appContext, listener, id, destination);

	checkArgument(!srcs.isEmpty());
	this.mSrcFiles = srcs;
	}

	@Override
	Builder createProgressBuilder() {
	return super.createProgressBuilder(
	serviceContext.getString(R.string.copy_notification_title),
	R.drawable.ic_menu_copy,
	serviceContext.getString(android.R.string.cancel),
	R.drawable.ic_cab_cancel);
	}

	@Override
	public Notification getSetupNotification() {
	return getSetupNotification(serviceContext.getString(R.string.copy_preparing));
	}

	public boolean shouldUpdateProgress() {
	// Wait a while between updates :)
	return elapsedRealtime() - mLastNotificationTime > PROGRESS_INTERVAL_MILLIS;
	}

	Notification getProgressNotification(@StringRes int msgId) {
	double completed = (double) this.mBytesCopied / mBatchSize;
	mProgressBuilder.setProgress(100, (int) (completed * 100), false);
	mProgressBuilder.setContentInfo(
	NumberFormat.getPercentInstance().format(completed));
	if (mRemainingTime > 0) {
	mProgressBuilder.setContentText(serviceContext.getString(msgId,
	DateUtils.formatDuration(mRemainingTime)));
	} else {
	mProgressBuilder.setContentText(null);
	}

	// Remember when we last returned progress so we can provide an answer
	// in shouldUpdateProgress.
	mLastNotificationTime = elapsedRealtime();
	return mProgressBuilder.build();
	}

	public Notification getProgressNotification() {
	return getProgressNotification(R.string.copy_remaining);
	}

	void onBytesCopied(long numBytes) {
	this.mBytesCopied += numBytes;
	}

	/**
	* Generates an estimate of the remaining time in the copy.
	*/
	void updateRemainingTimeEstimate() {
	long elapsedTime = elapsedRealtime() - mStartTime;

	final long sampleDuration = elapsedTime - mSampleTime;
	final long sampleSpeed = ((mBytesCopied - mBytesCopiedSample) * 1000) / sampleDuration;
	if (mSpeed == 0) {
	mSpeed = sampleSpeed;
	} else {
	mSpeed = ((3 * mSpeed) + sampleSpeed) / 4;
	}

	if (mSampleTime > 0 && mSpeed > 0) {
	mRemainingTime = ((mBatchSize - mBytesCopied) * 1000) / mSpeed;
	} else {
	mRemainingTime = 0;
	}

	mSampleTime = elapsedTime;
	mBytesCopiedSample = mBytesCopied;
	}

	@Override
	Notification getFailureNotification() {
	return getFailureNotification(
	R.plurals.copy_error_notification_title, R.drawable.ic_menu_copy);
	}

	@Override
	void run(FileOperationService service) throws RemoteException {
	mStartTime = elapsedRealtime();

	// Acquire content providers.
	srcClient = acquireUnstableProviderOrThrow(
	getContentResolver(),
	mSrcFiles.get(0).authority);
	dstClient = acquireUnstableProviderOrThrow(
	getContentResolver(),
	stack.peek().authority);

	// client
	mBatchSize = calculateSize(srcClient, mSrcFiles);

	DocumentInfo srcInfo;
	DocumentInfo dstInfo;
	for (int i = 0; i < mSrcFiles.size() && !isCanceled(); ++i) {
	srcInfo = mSrcFiles.get(i);
	dstInfo = stack.peek();

	// Guard unsupported recursive operation.
	if (dstInfo.equals(srcInfo) \|\| isDescendentOf(srcInfo, dstInfo)) {
	if (DEBUG) Log.d(TAG, "Skipping recursive operation on directory "
	+ dstInfo.derivedUri);
	onFileFailed(srcInfo);
	continue;
	}

	if (DEBUG) Log.d(TAG,
	"Performing op-type:" + type() + " of " + srcInfo.displayName
	+ " (" + srcInfo.derivedUri + ")" + " to " + dstInfo.displayName
	+ " (" + dstInfo.derivedUri + ")");

	processDocument(srcInfo, dstInfo);
	}
	}

	/**
	* Logs progress on the current copy operation. Displays/Updates the progress notification.
	*
	* @param bytesCopied
	*/
	private void makeCopyProgress(long bytesCopied) {
	onBytesCopied(bytesCopied);
	if (shouldUpdateProgress()) {
	updateRemainingTimeEstimate();
	listener.onProgress(this);
	}
	}

	/**
	* Copies a the given document to the given location.
	*
	* @param srcInfo DocumentInfos for the documents to copy.
	* @param dstDirInfo The destination directory.
	* @param mode The transfer mode (copy or move).
	* @return True on success, false on failure.
	* @throws RemoteException
	*/
	boolean processDocument(DocumentInfo srcInfo, DocumentInfo dstDirInfo) throws RemoteException {

	// TODO: When optimized copy kicks in, we'll not making any progress updates.
	// For now. Local storage isn't using optimized copy.

	// When copying within the same provider, try to use optimized copying and moving.
	// If not supported, then fallback to byte-by-byte copy/move.
	if (srcInfo.authority.equals(dstDirInfo.authority)) {
	if ((srcInfo.flags & Document.FLAG_SUPPORTS_COPY) != 0) {
	if (DocumentsContract.copyDocument(srcClient, srcInfo.derivedUri,
	dstDirInfo.derivedUri) == null) {
	onFileFailed(srcInfo);
	}
	return false;
	}
	}

	// If we couldn't do an optimized copy...we fall back to vanilla byte copy.
	return byteCopyDocument(srcInfo, dstDirInfo);
	}

	boolean byteCopyDocument(DocumentInfo srcInfo, DocumentInfo dstDirInfo)
	throws RemoteException {
	final String dstMimeType;
	final String dstDisplayName;

	// If the file is virtual, but can be converted to another format, then try to copy it
	// as such format. Also, append an extension for the target mime type (if known).
	if (srcInfo.isVirtualDocument()) {
	final String[] streamTypes = getContentResolver().getStreamTypes(
	srcInfo.derivedUri, "/");
	if (streamTypes != null && streamTypes.length > 0) {
	dstMimeType = streamTypes[0];
	final String extension = MimeTypeMap.getSingleton().
	getExtensionFromMimeType(dstMimeType);
	dstDisplayName = srcInfo.displayName +
	(extension != null ? "." + extension : srcInfo.displayName);
	} else {
	// The virtual file is not available as any alternative streamable format.
	// TODO: Log failures.
	onFileFailed(srcInfo);
	return false;
	}
	} else {
	dstMimeType = srcInfo.mimeType;
	dstDisplayName = srcInfo.displayName;
	}

	// Create the target document (either a file or a directory), then copy recursively the
	// contents (bytes or children).
	final Uri dstUri = DocumentsContract.createDocument(dstClient,
	dstDirInfo.derivedUri, dstMimeType, dstDisplayName);
	if (dstUri == null) {
	// If this is a directory, the entire subdir will not be copied over.
	onFileFailed(srcInfo);
	return false;
	}

	DocumentInfo dstInfo = null;
	try {
	dstInfo = DocumentInfo.fromUri(getContentResolver(), dstUri);
	} catch (FileNotFoundException e) {
	onFileFailed(srcInfo);
	return false;
	}

	final boolean success;
	if (Document.MIME_TYPE_DIR.equals(srcInfo.mimeType)) {
	success = copyDirectoryHelper(srcInfo, dstInfo);
	} else {
	success = copyFileHelper(srcInfo, dstInfo, dstMimeType);
	}

	return success;
	}

	/**
	* Handles recursion into a directory and copying its contents. Note that in linux terms, this
	* does the equivalent of "cp src/* dst", not "cp -r src dst".
	*
	* @param srcDirInfo Info of the directory to copy from. The routine will copy the directory's
	* contents, not the directory itself.
	* @param dstDirInfo Info of the directory to copy to. Must be created beforehand.
	* @return True on success, false if some of the children failed to copy.
	* @throws RemoteException
	*/
	private boolean copyDirectoryHelper(DocumentInfo srcDirInfo, DocumentInfo dstDirInfo)
	throws RemoteException {
	// Recurse into directories. Copy children into the new subdirectory.
	final String queryColumns[] = new String[] {
	Document.COLUMN_DISPLAY_NAME,
	Document.COLUMN_DOCUMENT_ID,
	Document.COLUMN_MIME_TYPE,
	Document.COLUMN_SIZE,
	Document.COLUMN_FLAGS
	};
	Cursor cursor = null;
	boolean success = true;
	try {
	// Iterate over srcs in the directory; copy to the destination directory.
	final Uri queryUri = DocumentsContract.buildChildDocumentsUri(srcDirInfo.authority,
	srcDirInfo.documentId);
	cursor = srcClient.query(queryUri, queryColumns, null, null, null);
	DocumentInfo srcInfo;
	while (cursor.moveToNext()) {
	srcInfo = DocumentInfo.fromCursor(cursor, srcDirInfo.authority);
	success &= processDocument(srcInfo, dstDirInfo);
	}
	} finally {
	IoUtils.closeQuietly(cursor);
	}

	return success;
	}

	/**
	* Handles copying a single file.
	*
	* @param srcUriInfo Info of the file to copy from.
	* @param dstUriInfo Info of the file to copy to. Must be created beforehand.
	* @param mimeType Mime type for the target. Can be different than source for virtual files.
	* @return True on success, false on error.
	* @throws RemoteException
	*/
	private boolean copyFileHelper(DocumentInfo srcInfo, DocumentInfo dstInfo, String mimeType)
	throws RemoteException {
	// Copy an individual file.
	CancellationSignal canceller = new CancellationSignal();
	ParcelFileDescriptor srcFile = null;
	ParcelFileDescriptor dstFile = null;
	InputStream src = null;
	OutputStream dst = null;

	boolean success = true;
	try {
	// If the file is virtual, but can be converted to another format, then try to copy it
	// as such format.
	if (srcInfo.isVirtualDocument()) {
	final AssetFileDescriptor srcFileAsAsset =
	srcClient.openTypedAssetFileDescriptor(
	srcInfo.derivedUri, mimeType, null, canceller);
	srcFile = srcFileAsAsset.getParcelFileDescriptor();
	src = new AssetFileDescriptor.AutoCloseInputStream(srcFileAsAsset);
	} else {
	srcFile = srcClient.openFile(srcInfo.derivedUri, "r", canceller);
	src = new ParcelFileDescriptor.AutoCloseInputStream(srcFile);
	}

	dstFile = dstClient.openFile(dstInfo.derivedUri, "w", canceller);
	dst = new ParcelFileDescriptor.AutoCloseOutputStream(dstFile);

	byte[] buffer = new byte[8192];
	int len;
	while ((len = src.read(buffer)) != -1) {
	if (isCanceled()) {
	if (DEBUG) Log.d(TAG, "Canceled copy mid-copy. Id:" + id);
	success = false;
	break;
	}
	dst.write(buffer, 0, len);
	makeCopyProgress(len);
	}

	srcFile.checkError();
	} catch (IOException e) {
	success = false;
	onFileFailed(srcInfo);

	if (dstFile != null) {
	try {
	dstFile.closeWithError(e.getMessage());
	} catch (IOException closeError) {
	Log.e(TAG, "Error closing destination", closeError);
	}
	}
	} finally {
	// This also ensures the file descriptors are closed.
	IoUtils.closeQuietly(src);
	IoUtils.closeQuietly(dst);
	}

	if (!success) {
	// Clean up half-copied files.
	canceller.cancel();
	try {
	DocumentsContract.deleteDocument(dstClient, dstInfo.derivedUri);
	} catch (RemoteException e) {
	// RemoteExceptions usually signal that the connection is dead, so there's no
	// point attempting to continue. Propagate the exception up so the copy job is
	// cancelled.
	Log.w(TAG, "Failed to cleanup after copy error: " + srcInfo.derivedUri, e);
	throw e;
	}
	}

	return success;
	}

	/**
	* Calculates the cumulative size of all the documents in the list. Directories are recursed
	* into and totaled up.
	*
	* @param srcs
	* @return Size in bytes.
	* @throws RemoteException
	*/
	private static long calculateSize(ContentProviderClient client, List<DocumentInfo> srcs)
	throws RemoteException {
	long result = 0;

	for (DocumentInfo src : srcs) {
	if (src.isDirectory()) {
	// Directories need to be recursed into.
	result += calculateFileSizesRecursively(client, src.derivedUri);
	} else {
	result += src.size;
	}
	}
	return result;
	}

	/**
	* Calculates (recursively) the cumulative size of all the files under the given directory.
	*
	* @throws RemoteException
	*/
	private static long calculateFileSizesRecursively(
	ContentProviderClient client, Uri uri) throws RemoteException {
	final String authority = uri.getAuthority();
	final Uri queryUri = DocumentsContract.buildChildDocumentsUri(authority,
	DocumentsContract.getDocumentId(uri));
	final String queryColumns[] = new String[] {
	Document.COLUMN_DOCUMENT_ID,
	Document.COLUMN_MIME_TYPE,
	Document.COLUMN_SIZE
	};

	long result = 0;
	Cursor cursor = null;
	try {
	cursor = client.query(queryUri, queryColumns, null, null, null);
	while (cursor.moveToNext()) {
	if (Document.MIME_TYPE_DIR.equals(
	getCursorString(cursor, Document.COLUMN_MIME_TYPE))) {
	// Recurse into directories.
	final Uri dirUri = DocumentsContract.buildDocumentUri(authority,
	getCursorString(cursor, Document.COLUMN_DOCUMENT_ID));
	result += calculateFileSizesRecursively(client, dirUri);
	} else {
	// This may return -1 if the size isn't defined. Ignore those cases.
	long size = getCursorLong(cursor, Document.COLUMN_SIZE);
	result += size > 0 ? size : 0;
	}
	}
	} finally {
	IoUtils.closeQuietly(cursor);
	}

	return result;
	}

	@Override
	void cleanup() {
	ContentProviderClient.releaseQuietly(srcClient);
	ContentProviderClient.releaseQuietly(dstClient);
	}

	/**
	* Returns true if {@code doc} is a descendant of {@code parentDoc}.
	* @throws RemoteException
	*/
	boolean isDescendentOf(DocumentInfo doc, DocumentInfo parentDoc)
	throws RemoteException {
	if (parentDoc.isDirectory() && doc.authority.equals(parentDoc.authority)) {
	return DocumentsContract.isChildDocument(
	dstClient, doc.derivedUri, parentDoc.derivedUri);
	}
	return false;
	}
	}