X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/407f64f5e062cbd59b82043406923f082c6fa911..e6fc5d13ad8aff2f70a84d9cf96b253a108b836d:/src/com/owncloud/android/operations/SynchronizeFolderOperation.java diff --git a/src/com/owncloud/android/operations/SynchronizeFolderOperation.java b/src/com/owncloud/android/operations/SynchronizeFolderOperation.java index 72ccd135..f12d5dd7 100644 --- a/src/com/owncloud/android/operations/SynchronizeFolderOperation.java +++ b/src/com/owncloud/android/operations/SynchronizeFolderOperation.java @@ -36,14 +36,7 @@ import com.owncloud.android.lib.resources.files.RemoteFile; import com.owncloud.android.operations.common.SyncOperation; import com.owncloud.android.utils.FileStorageUtils; -import org.apache.http.HttpStatus; - import java.io.File; -import java.io.FileInputStream; -import java.io.FileOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -72,34 +65,42 @@ public class SynchronizeFolderOperation extends SyncOperation { /** Time stamp for the synchronization process in progress */ private long mCurrentSyncTime; - /** Remote folder to synchronize */ - private OCFile mLocalFolder; - + /** Remote path of the folder to synchronize */ + private String mRemotePath; + /** Account where the file to synchronize belongs */ private Account mAccount; /** Android context; necessary to send requests to the download service */ private Context mContext; + /** Locally cached information about folder to synchronize */ + private OCFile mLocalFolder; + /** Files and folders contained in the synchronized folder after a successful operation */ - private List mChildren; + //private List mChildren; /** Counter of conflicts found between local and remote files */ private int mConflictsFound; /** Counter of failed operations in synchronization of kept-in-sync files */ - private int mFailsInFavouritesFound; - - /** - * Map of remote and local paths to files that where locally stored in a location - * out of the ownCloud folder and couldn't be copied automatically into it - **/ - private Map mForgottenLocalFiles; + private int mFailsInFileSyncsFound; /** 'True' means that the remote folder changed and should be fetched */ private boolean mRemoteFolderChanged; - private final AtomicBoolean mCancellationRequested = new AtomicBoolean(false); + private List mFilesForDirectDownload; + // to avoid extra PROPFINDs when there was no change in the folder + + private List mFilesToSyncContentsWithoutUpload; + // this will go out when 'folder synchronization' replaces 'folder download'; step by step + + private List mFavouriteFilesToSyncContents; + // this will be used for every file when 'folder synchronization' replaces 'folder download' + + private List mFoldersToWalkDown; + + private final AtomicBoolean mCancellationRequested; /** * Creates a new instance of {@link SynchronizeFolderOperation}. @@ -110,12 +111,16 @@ public class SynchronizeFolderOperation extends SyncOperation { * @param currentSyncTime Time stamp for the synchronization process in progress. */ public SynchronizeFolderOperation(Context context, String remotePath, Account account, long currentSyncTime){ - mLocalFolder = new OCFile(remotePath); + mRemotePath = remotePath; mCurrentSyncTime = currentSyncTime; mAccount = account; mContext = context; - mForgottenLocalFiles = new HashMap(); mRemoteFolderChanged = false; + mFilesForDirectDownload = new Vector(); + mFilesToSyncContentsWithoutUpload = new Vector(); + mFavouriteFilesToSyncContents = new Vector(); + mFoldersToWalkDown = new Vector(); + mCancellationRequested = new AtomicBoolean(false); } @@ -123,22 +128,8 @@ public class SynchronizeFolderOperation extends SyncOperation { return mConflictsFound; } - public int getFailsInFavouritesFound() { - return mFailsInFavouritesFound; - } - - public Map getForgottenLocalFiles() { - return mForgottenLocalFiles; - } - - /** - * Returns the list of files and folders contained in the synchronized folder, - * if called after synchronization is complete. - * - * @return List of files and folders contained in the synchronized folder. - */ - public List getChildren() { - return mChildren; + public int getFailsInFileSyncsFound() { + return mFailsInFileSyncsFound; } /** @@ -149,41 +140,68 @@ public class SynchronizeFolderOperation extends SyncOperation { @Override protected RemoteOperationResult run(OwnCloudClient client) { RemoteOperationResult result = null; - mFailsInFavouritesFound = 0; + mFailsInFileSyncsFound = 0; mConflictsFound = 0; - mForgottenLocalFiles.clear(); + + try { + // get locally cached information about folder + mLocalFolder = getStorageManager().getFileByPath(mRemotePath); + + result = checkForChanges(client); + + if (result.isSuccess()) { + if (mRemoteFolderChanged) { + result = fetchAndSyncRemoteFolder(client); + + } else { + prepareOpsFromLocalKnowledge(); + } + + if (result.isSuccess()) { + syncContents(client); + } - /// perform the download - synchronized(mCancellationRequested) { - if (mCancellationRequested.get()) { - return new RemoteOperationResult(new OperationCancelledException()); + if (mFilesForDirectDownload.isEmpty()) { + sendBroadcastForNotifyingUIUpdate(result.isSuccess()); + } } - } - - result = checkForChanges(client); - - if (result.isSuccess()) { - if (mRemoteFolderChanged) { - result = fetchAndSyncRemoteFolder(client); - } else { - mChildren = getStorageManager().getFolderContent(mLocalFolder); + + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); } + + } catch (OperationCancelledException e) { + result = new RemoteOperationResult(e); + + // Needed in case that cancellation occurs before starting any download. + // If not, yellow arrow continues being shown. + sendBroadcastForNotifyingUIUpdate(result.isSuccess()); + + /// cancellation of download needs to be done separately in any case; a SynchronizeFolderOperation + // may finish much sooner than the real download of the files in the folder + Intent intent = new Intent(mContext, FileDownloader.class); + intent.setAction(FileDownloader.ACTION_CANCEL_FILE_DOWNLOAD); + intent.putExtra(FileDownloader.EXTRA_ACCOUNT, mAccount); + intent.putExtra(FileDownloader.EXTRA_FILE, mLocalFolder); + mContext.startService(intent); } return result; } - private RemoteOperationResult checkForChanges(OwnCloudClient client) { + private RemoteOperationResult checkForChanges(OwnCloudClient client) throws OperationCancelledException { + Log_OC.d(TAG, "Checking changes in " + mAccount.name + mRemotePath); + mRemoteFolderChanged = true; RemoteOperationResult result = null; - String remotePath = null; - - remotePath = mLocalFolder.getRemotePath(); - Log_OC.d(TAG, "Checking changes in " + mAccount.name + remotePath); - + + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + // remote request - ReadRemoteFileOperation operation = new ReadRemoteFileOperation(remotePath); + ReadRemoteFileOperation operation = new ReadRemoteFileOperation(mRemotePath); result = operation.execute(client); if (result.isSuccess()){ OCFile remoteFolder = FileStorageUtils.fillOCFile((RemoteFile) result.getData().get(0)); @@ -194,7 +212,7 @@ public class SynchronizeFolderOperation extends SyncOperation { result = new RemoteOperationResult(ResultCode.OK); - Log_OC.i(TAG, "Checked " + mAccount.name + remotePath + " : " + + Log_OC.i(TAG, "Checked " + mAccount.name + mRemotePath + " : " + (mRemoteFolderChanged ? "changed" : "not changed")); } else { @@ -203,27 +221,32 @@ public class SynchronizeFolderOperation extends SyncOperation { removeLocalFolder(); } if (result.isException()) { - Log_OC.e(TAG, "Checked " + mAccount.name + remotePath + " : " + + Log_OC.e(TAG, "Checked " + mAccount.name + mRemotePath + " : " + result.getLogMessage(), result.getException()); } else { - Log_OC.e(TAG, "Checked " + mAccount.name + remotePath + " : " + + Log_OC.e(TAG, "Checked " + mAccount.name + mRemotePath + " : " + result.getLogMessage()); } + + sendBroadcastForNotifyingUIUpdate(result.isSuccess()); } return result; } - private RemoteOperationResult fetchAndSyncRemoteFolder(OwnCloudClient client) { - String remotePath = mLocalFolder.getRemotePath(); - ReadRemoteFolderOperation operation = new ReadRemoteFolderOperation(remotePath); + private RemoteOperationResult fetchAndSyncRemoteFolder(OwnCloudClient client) throws OperationCancelledException { + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + + ReadRemoteFolderOperation operation = new ReadRemoteFolderOperation(mRemotePath); RemoteOperationResult result = operation.execute(client); - Log_OC.d(TAG, "Synchronizing " + mAccount.name + remotePath); + Log_OC.d(TAG, "Synchronizing " + mAccount.name + mRemotePath); if (result.isSuccess()) { synchronizeData(result.getData(), client); - if (mConflictsFound > 0 || mFailsInFavouritesFound > 0) { + if (mConflictsFound > 0 || mFailsInFileSyncsFound > 0) { result = new RemoteOperationResult(ResultCode.SYNC_CONFLICT); // should be a different result code, but will do the job } @@ -231,6 +254,7 @@ public class SynchronizeFolderOperation extends SyncOperation { if (result.getCode() == ResultCode.FILE_NOT_FOUND) removeLocalFolder(); } + return result; } @@ -243,7 +267,7 @@ public class SynchronizeFolderOperation extends SyncOperation { storageManager.removeFolder( mLocalFolder, true, - ( mLocalFolder.isDown() && + ( mLocalFolder.isDown() && // TODO: debug, I think this is always false for folders mLocalFolder.getStoragePath().startsWith(currentSavePath) ) ); @@ -263,12 +287,10 @@ public class SynchronizeFolderOperation extends SyncOperation { * retrieved. * @return 'True' when any change was made in the local data, 'false' otherwise */ - private void synchronizeData(ArrayList folderAndFiles, OwnCloudClient client) { + private void synchronizeData(ArrayList folderAndFiles, OwnCloudClient client) + throws OperationCancelledException { FileDataStorageManager storageManager = getStorageManager(); - // get 'fresh data' from the database - mLocalFolder = storageManager.getFileByPath(mLocalFolder.getRemotePath()); - // parse data from remote folder OCFile remoteFolder = fillOCFile((RemoteFile)folderAndFiles.get(0)); remoteFolder.setParentId(mLocalFolder.getParentId()); @@ -278,7 +300,16 @@ public class SynchronizeFolderOperation extends SyncOperation { + " changed - starting update of local data "); List updatedFiles = new Vector(folderAndFiles.size() - 1); - List filesToSyncContents = new Vector(); + mFilesForDirectDownload.clear(); + mFilesToSyncContentsWithoutUpload.clear(); + mFavouriteFilesToSyncContents.clear(); + + synchronized(mFoldersToWalkDown) { + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + mFoldersToWalkDown.clear(); + } // get current data about local contents of the folder to synchronize List localFiles = storageManager.getFolderContent(mLocalFolder); @@ -287,7 +318,7 @@ public class SynchronizeFolderOperation extends SyncOperation { localFilesMap.put(file.getRemotePath(), file); } - // loop to update every child + // loop to synchronize every child OCFile remoteFile = null, localFile = null; for (int i=1; i children = getStorageManager().getFolderContent(mLocalFolder); + for (OCFile child : children) { + /// classify file to sync/download contents later + if (child.isFolder()) { + /// to download children files recursively + SynchronizeFolderOperation synchFolderOp = new SynchronizeFolderOperation( + mContext, + child.getRemotePath(), + mAccount, + mCurrentSyncTime + ); + + synchronized(mFoldersToWalkDown) { + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + mFoldersToWalkDown.add(synchFolderOp); + } + + } else { + /// prepare limited synchronization for regular files + if (!child.isDown()) { + mFilesForDirectDownload.add(child); + } + } + } + } + - mChildren = updatedFiles; + private void syncContents(OwnCloudClient client) throws OperationCancelledException { + startDirectDownloads(); + startContentSynchronizations(mFilesToSyncContentsWithoutUpload, client); + startContentSynchronizations(mFavouriteFilesToSyncContents, client); + walkSubfolders(client); // this must be the last! + } + + + private void startDirectDownloads() throws OperationCancelledException { + for (OCFile file : mFilesForDirectDownload) { + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + Intent i = new Intent(mContext, FileDownloader.class); + i.putExtra(FileDownloader.EXTRA_ACCOUNT, mAccount); + i.putExtra(FileDownloader.EXTRA_FILE, file); + mContext.startService(i); + } } /** @@ -380,34 +472,54 @@ public class SynchronizeFolderOperation extends SyncOperation { * @param filesToSyncContents Synchronization operations to execute. * @param client Interface to the remote ownCloud server. */ - private void startContentSynchronizations( - List filesToSyncContents, OwnCloudClient client - ) { + private void startContentSynchronizations(List filesToSyncContents, OwnCloudClient client) + throws OperationCancelledException { + RemoteOperationResult contentsResult = null; - for (SynchronizeFileOperation op: filesToSyncContents) { - contentsResult = op.execute(getStorageManager(), mContext); // async + for (SyncOperation op: filesToSyncContents) { + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + contentsResult = op.execute(getStorageManager(), mContext); if (!contentsResult.isSuccess()) { if (contentsResult.getCode() == ResultCode.SYNC_CONFLICT) { mConflictsFound++; } else { - mFailsInFavouritesFound++; + mFailsInFileSyncsFound++; if (contentsResult.getException() != null) { - Log_OC.e(TAG, "Error while synchronizing favourites : " + Log_OC.e(TAG, "Error while synchronizing file : " + contentsResult.getLogMessage(), contentsResult.getException()); } else { - Log_OC.e(TAG, "Error while synchronizing favourites : " + Log_OC.e(TAG, "Error while synchronizing file : " + contentsResult.getLogMessage()); } } + // TODO - use the errors count in notifications } // won't let these fails break the synchronization process } } - public boolean isMultiStatus(int status) { - return (status == HttpStatus.SC_MULTI_STATUS); + private void walkSubfolders(OwnCloudClient client) throws OperationCancelledException { + RemoteOperationResult contentsResult = null; + for (SyncOperation op: mFoldersToWalkDown) { + if (mCancellationRequested.get()) { + throw new OperationCancelledException(); + } + contentsResult = op.execute(client, getStorageManager()); // to watch out: possibly deep recursion + if (!contentsResult.isSuccess()) { + // TODO - some kind of error count, and use it with notifications + if (contentsResult.getException() != null) { + Log_OC.e(TAG, "Non blocking exception : " + + contentsResult.getLogMessage(), contentsResult.getException()); + } else { + Log_OC.e(TAG, "Non blocking error : " + contentsResult.getLogMessage()); + } + } // won't let these fails break the synchronization process + } } + /** * Creates and populates a new {@link com.owncloud.android.datamodel.OCFile} object with the data read from the server. * @@ -428,74 +540,6 @@ public class SynchronizeFolderOperation extends SyncOperation { /** - * Checks the storage path of the OCFile received as parameter. - * If it's out of the local ownCloud folder, tries to copy the file inside it. - * - * If the copy fails, the link to the local file is nullified. The account of forgotten - * files is kept in {@link #mForgottenLocalFiles} - *) - * @param file File to check and fix. - */ - private void checkAndFixForeignStoragePath(OCFile file) { - String storagePath = file.getStoragePath(); - String expectedPath = FileStorageUtils.getDefaultSavePathFor(mAccount.name, file); - if (storagePath != null && !storagePath.equals(expectedPath)) { - /// fix storagePaths out of the local ownCloud folder - File originalFile = new File(storagePath); - if (FileStorageUtils.getUsableSpace(mAccount.name) < originalFile.length()) { - mForgottenLocalFiles.put(file.getRemotePath(), storagePath); - file.setStoragePath(null); - - } else { - InputStream in = null; - OutputStream out = null; - try { - File expectedFile = new File(expectedPath); - File expectedParent = expectedFile.getParentFile(); - expectedParent.mkdirs(); - if (!expectedParent.isDirectory()) { - throw new IOException( - "Unexpected error: parent directory could not be created" - ); - } - expectedFile.createNewFile(); - if (!expectedFile.isFile()) { - throw new IOException("Unexpected error: target file could not be created"); - } - in = new FileInputStream(originalFile); - out = new FileOutputStream(expectedFile); - byte[] buf = new byte[1024]; - int len; - while ((len = in.read(buf)) > 0){ - out.write(buf, 0, len); - } - file.setStoragePath(expectedPath); - - } catch (Exception e) { - Log_OC.e(TAG, "Exception while copying foreign file " + expectedPath, e); - mForgottenLocalFiles.put(file.getRemotePath(), storagePath); - file.setStoragePath(null); - - } finally { - try { - if (in != null) in.close(); - } catch (Exception e) { - Log_OC.d(TAG, "Weird exception while closing input stream for " - + storagePath + " (ignoring)", e); - } - try { - if (out != null) out.close(); - } catch (Exception e) { - Log_OC.d(TAG, "Weird exception while closing output stream for " - + expectedPath + " (ignoring)", e); - } - } - } - } - } - - - /** * Scans the default location for saving local copies of files searching for * a 'lost' file with the same full name as the {@link com.owncloud.android.datamodel.OCFile} received as * parameter. @@ -512,28 +556,36 @@ public class SynchronizeFolderOperation extends SyncOperation { } } - /** - * Requests for a download to the FileDownloader service - * - * @param file OCFile object representing the file to download - */ - private void requestForDownloadFile(OCFile file) { - Intent i = new Intent(mContext, FileDownloader.class); - i.putExtra(FileDownloader.EXTRA_ACCOUNT, mAccount); - i.putExtra(FileDownloader.EXTRA_FILE, file); - mContext.startService(i); + private void sendBroadcastForNotifyingUIUpdate(boolean result) { + // Send a broadcast message for notifying UI update + Intent uiUpdate = new Intent(FileDownloader.getDownloadFinishMessage()); + uiUpdate.putExtra(FileDownloader.EXTRA_DOWNLOAD_RESULT, result); + uiUpdate.putExtra(FileDownloader.ACCOUNT_NAME, mAccount.name); + uiUpdate.putExtra(FileDownloader.EXTRA_REMOTE_PATH, mRemotePath); + uiUpdate.putExtra(FileDownloader.EXTRA_FILE_PATH, mLocalFolder.getRemotePath()); + mContext.sendStickyBroadcast(uiUpdate); } + /** * Cancel operation */ - public void cancel(){ - // WIP Cancel the sync operation + public void cancel() { mCancellationRequested.set(true); - } - public boolean getRemoteFolderChanged() { - return mRemoteFolderChanged; + synchronized(mFoldersToWalkDown) { + // cancel 'child' synchronizations + for (SyncOperation synchOp : mFoldersToWalkDown) { + ((SynchronizeFolderOperation) synchOp).cancel(); + } + } } + public String getFolderPath() { + String path = mLocalFolder.getStoragePath(); + if (path != null && path.length() > 0) { + return path; + } + return FileStorageUtils.getDefaultSavePathFor(mAccount.name, mLocalFolder); + } }