X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/ab3bcf6fe6f62add623a60405ef96ea77839f7a4..bcc972d63d3ed1d76b51a8a03a27e809983dc756:/src/com/owncloud/android/operations/SynchronizeFolderOperation.java?ds=sidebyside diff --git a/src/com/owncloud/android/operations/SynchronizeFolderOperation.java b/src/com/owncloud/android/operations/SynchronizeFolderOperation.java index 7f22bb7a..e93736c4 100644 --- a/src/com/owncloud/android/operations/SynchronizeFolderOperation.java +++ b/src/com/owncloud/android/operations/SynchronizeFolderOperation.java @@ -30,84 +30,105 @@ import java.util.Map; import java.util.Vector; import org.apache.http.HttpStatus; -import org.apache.jackrabbit.webdav.MultiStatus; +import org.apache.jackrabbit.webdav.DavConstants; import org.apache.jackrabbit.webdav.client.methods.PropFindMethod; import android.accounts.Account; import android.content.Context; import android.content.Intent; -import com.owncloud.android.Log_OC; -import com.owncloud.android.datamodel.DataStorageManager; +import com.owncloud.android.datamodel.FileDataStorageManager; import com.owncloud.android.datamodel.OCFile; -import com.owncloud.android.operations.RemoteOperationResult.ResultCode; +import com.owncloud.android.oc_framework.network.webdav.WebdavClient; +import com.owncloud.android.oc_framework.network.webdav.WebdavEntry; +import com.owncloud.android.oc_framework.network.webdav.WebdavUtils; +import com.owncloud.android.oc_framework.operations.RemoteOperation; +import com.owncloud.android.oc_framework.operations.RemoteOperationResult; +import com.owncloud.android.oc_framework.operations.RemoteOperationResult.ResultCode; +import com.owncloud.android.oc_framework.operations.remote.ReadRemoteFolderOperation; +import com.owncloud.android.oc_framework.operations.RemoteFile; import com.owncloud.android.syncadapter.FileSyncService; import com.owncloud.android.utils.FileStorageUtils; +import com.owncloud.android.utils.Log_OC; -import eu.alefzero.webdav.WebdavClient; -import eu.alefzero.webdav.WebdavEntry; -import eu.alefzero.webdav.WebdavUtils; /** - * Remote operation performing the synchronization a the contents of a remote folder with the local database + * Remote operation performing the synchronization of the list of files contained + * in a folder identified with its remote path. + * + * Fetches the list and properties of the files contained in the given folder, including their + * properties, and updates the local database with them. + * + * Does NOT enter in the child folders to synchronize their contents also. * - * @author David A. Velasco + * @author David A. Velasco */ public class SynchronizeFolderOperation extends RemoteOperation { private static final String TAG = SynchronizeFolderOperation.class.getSimpleName(); - /** Remote folder to synchronize */ - private String mRemotePath; - /** Timestamp for the synchronization in progress */ + /** Time stamp for the synchronization process in progress */ private long mCurrentSyncTime; - /** Id of the folder to synchronize in the local database */ - private long mParentId; + /** Remote folder to synchronize */ + private OCFile mLocalFolder; - /** Boolean to indicate if is mandatory to update the folder */ - private boolean mEnforceMetadataUpdate; - /** Access to the local database */ - private DataStorageManager mStorageManager; + private FileDataStorageManager mStorageManager; /** Account where the file to synchronize belongs */ private Account mAccount; - /** Android context; necessary to send requests to the download service; maybe something to refactor */ + /** Android context; necessary to send requests to the download service */ private Context mContext; - /** Files and folders contained in the synchronized folder */ + /** Files and folders contained in the synchronized folder after a successful operation */ 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; - + + /** 'True' means that this operation is part of a full account synchronization */ private boolean mSyncFullAccount; + + /** 'True' means that the remote folder changed from last synchronization and should be fetched */ + private boolean mRemoteFolderChanged; - public SynchronizeFolderOperation( String remotePath, + /** + * Creates a new instance of {@link SynchronizeFolderOperation}. + * + * @param remoteFolderPath Remote folder to synchronize. + * @param currentSyncTime Time stamp for the synchronization process in progress. + * @param localFolderId Identifier in the local database of the folder to synchronize. + * @param updateFolderProperties 'True' means that the properties of the folder should be updated also, not just its content. + * @param syncFullAccount 'True' means that this operation is part of a full account synchronization. + * @param dataStorageManager Interface with the local database. + * @param account ownCloud account where the folder is located. + * @param context Application context. + */ + public SynchronizeFolderOperation( OCFile folder, long currentSyncTime, - long parentId, - boolean enforceMetadataUpdate, boolean syncFullAccount, - DataStorageManager dataStorageManager, + FileDataStorageManager dataStorageManager, Account account, Context context ) { - mRemotePath = remotePath; + mLocalFolder = folder; mCurrentSyncTime = currentSyncTime; - mParentId = parentId; - mEnforceMetadataUpdate = enforceMetadataUpdate; mSyncFullAccount = syncFullAccount; mStorageManager = dataStorageManager; mAccount = account; mContext = context; mForgottenLocalFiles = new HashMap(); + mRemoteFolderChanged = false; } @@ -126,179 +147,75 @@ public class SynchronizeFolderOperation extends RemoteOperation { /** * 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. + * @return List of files and folders contained in the synchronized folder. */ public List getChildren() { return mChildren; } - public String getRemotePath() { - return mRemotePath; - } - - public long getParentId() { - return mParentId; - } - + /** + * Performs the synchronization. + * + * {@inheritDoc} + */ @Override protected RemoteOperationResult run(WebdavClient client) { RemoteOperationResult result = null; mFailsInFavouritesFound = 0; mConflictsFound = 0; mForgottenLocalFiles.clear(); - boolean dirChanged = false; + + result = checkForChanges(client); + + if (result.isSuccess()) { + if (mRemoteFolderChanged) { + result = fetchAndSyncRemoteFolder(client); + } else { + mChildren = mStorageManager.getFolderContent(mLocalFolder); + } + } + + if (!mSyncFullAccount) { + sendStickyBroadcast(false, mLocalFolder.getRemotePath(), result); + } - // code before in FileSyncAdapter.fetchData + return result; + + } + + + private RemoteOperationResult checkForChanges(WebdavClient client) { + mRemoteFolderChanged = false; + RemoteOperationResult result = null; + String remotePath = null; PropFindMethod query = null; + try { - Log_OC.d(TAG, "Synchronizing " + mAccount.name + ", fetching files in " + mRemotePath); + remotePath = mLocalFolder.getRemotePath(); + Log_OC.d(TAG, "Checking changes in " + mAccount.name + remotePath); // remote request - query = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(mRemotePath)); + query = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(remotePath), + DavConstants.PROPFIND_ALL_PROP, + DavConstants.DEPTH_0); int status = client.executeMethod(query); - // check and process response - /// TODO take into account all the possible status per child-resource - if (isMultiStatus(status)) { - MultiStatus resp = query.getResponseBodyAsMultiStatus(); - - // synchronize properties of the parent folder, if necessary - WebdavEntry we = new WebdavEntry(resp.getResponses()[0], client.getBaseUri().getPath()); - - // Properties of server folder - OCFile parent = fillOCFile(we); - // Properties of local folder - OCFile localParent = mStorageManager.getFileByPath(mRemotePath); - if (localParent == null || !(parent.getEtag().equalsIgnoreCase(localParent.getEtag())) || mEnforceMetadataUpdate) { - if (localParent != null) { - parent.setParentId(localParent.getParentId()); - } - mStorageManager.saveFile(parent); - if (mParentId == DataStorageManager.ROOT_PARENT_ID) - mParentId = parent.getFileId(); - dirChanged = true; - } - - if (dirChanged) { - // read contents in folder - List filesOnServer = new ArrayList (); // Contains the lists of files on server - List updatedFiles = new Vector(resp.getResponses().length - 1); - List filesToSyncContents = new Vector(); - for (int i = 1; i < resp.getResponses().length; ++i) { - /// new OCFile instance with the data from the server - we = new WebdavEntry(resp.getResponses()[i], client.getBaseUri().getPath()); - OCFile file = fillOCFile(we); - - filesOnServer.add(file.getRemotePath()); // Registry the file in the list - - /// set data about local state, keeping unchanged former data if existing - file.setLastSyncDateForProperties(mCurrentSyncTime); - OCFile oldFile = mStorageManager.getFileByPath(file.getRemotePath()); - - // Check if it is needed to synchronize the folder - if (oldFile != null) { - if (!file.getEtag().equalsIgnoreCase(oldFile.getEtag())) { - } - } - - if (oldFile != null) { - file.setKeepInSync(oldFile.keepInSync()); - file.setLastSyncDateForData(oldFile.getLastSyncDateForData()); - file.setModificationTimestampAtLastSyncForData(oldFile.getModificationTimestampAtLastSyncForData()); // must be kept unchanged when the file contents are not updated - checkAndFixForeignStoragePath(oldFile); - file.setStoragePath(oldFile.getStoragePath()); - if (file.isDirectory()) - file.setEtag(oldFile.getEtag()); - } else - if (file.isDirectory()) - file.setEtag(""); - - /// scan default location if local copy of file is not linked in OCFile instance - if (file.getStoragePath() == null && !file.isDirectory()) { - File f = new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, file)); - if (f.exists()) { - file.setStoragePath(f.getAbsolutePath()); - file.setLastSyncDateForData(f.lastModified()); - } - } - - /// prepare content synchronization for kept-in-sync files - if (file.keepInSync()) { - SynchronizeFileOperation operation = new SynchronizeFileOperation( oldFile, - file, - mStorageManager, - mAccount, - true, - false, - mContext - ); - filesToSyncContents.add(operation); - } - - updatedFiles.add(file); - } - - // save updated contents in local database; all at once, trying to get a best performance in database update (not a big deal, indeed) - mStorageManager.saveFiles(updatedFiles); - - // request for the synchronization of files AFTER saving last properties - RemoteOperationResult contentsResult = null; - for (SynchronizeFileOperation op: filesToSyncContents) { - contentsResult = op.execute(client); // returns without waiting for upload or download finishes - if (!contentsResult.isSuccess()) { - if (contentsResult.getCode() == ResultCode.SYNC_CONFLICT) { - mConflictsFound++; - } else { - mFailsInFavouritesFound++; - if (contentsResult.getException() != null) { - Log_OC.e(TAG, "Error while synchronizing favourites : " + contentsResult.getLogMessage(), contentsResult.getException()); - } else { - Log_OC.e(TAG, "Error while synchronizing favourites : " + contentsResult.getLogMessage()); - } - } - } // won't let these fails break the synchronization process - } - - // removal of obsolete files - mChildren = mStorageManager.getDirectoryContent(mStorageManager.getFileById(mParentId)); - OCFile file; - String currentSavePath = FileStorageUtils.getSavePath(mAccount.name); - for (int i=0; i < mChildren.size(); ) { - file = mChildren.get(i); - if (file.getLastSyncDateForProperties() != mCurrentSyncTime) { - Log_OC.d(TAG, "removing file: " + file); - mStorageManager.removeFile(file, (file.isDown() && file.getStoragePath().startsWith(currentSavePath))); - mChildren.remove(i); - } else { - i++; - } - } - - } else { - client.exhaustResponse(query.getResponseBodyAsStream()); - } + // check and process response + if (isMultiStatus(status)) { + // parse data from remote folder + WebdavEntry we = new WebdavEntry(query.getResponseBodyAsMultiStatus().getResponses()[0], client.getBaseUri().getPath()); + OCFile remoteFolder = fillOCFile(we); + // check if remote and local folder are different + mRemoteFolderChanged = !(remoteFolder.getEtag().equalsIgnoreCase(mLocalFolder.getEtag())); - // prepare result object - if (!dirChanged) { - result = new RemoteOperationResult(ResultCode.OK_NO_CHANGES_ON_DIR); - mChildren = mStorageManager.getDirectoryContent(mStorageManager.getFileById(mParentId)); - - } else { - if (mConflictsFound > 0 || mFailsInFavouritesFound > 0) { - result = new RemoteOperationResult(ResultCode.SYNC_CONFLICT); // should be different result, but will do the job - - } else { - result = new RemoteOperationResult(true, status, query.getResponseHeaders()); - } - } + result = new RemoteOperationResult(ResultCode.OK); } else { + // check failed + client.exhaustResponse(query.getResponseBodyAsStream()); if (status == HttpStatus.SC_NOT_FOUND) { - OCFile dir = mStorageManager.getFileByPath(mRemotePath); - if (dir != null) { - String currentSavePath = FileStorageUtils.getSavePath(mAccount.name); - mStorageManager.removeFile(dir, (dir.isDown() && dir.getStoragePath().startsWith(currentSavePath))); - } + removeLocalFolder(); } result = new RemoteOperationResult(false, status, query.getResponseHeaders()); } @@ -311,29 +228,177 @@ public class SynchronizeFolderOperation extends RemoteOperation { if (query != null) query.releaseConnection(); // let the connection available for other methods if (result.isSuccess()) { - Log_OC.i(TAG, "Synchroned " + mAccount.name + ", folder " + mRemotePath + ": " + result.getLogMessage()); + Log_OC.i(TAG, "Checked " + mAccount.name + remotePath + " : " + (mRemoteFolderChanged ? "changed" : "not changed")); } else { if (result.isException()) { - Log_OC.e(TAG, "Synchroned " + mAccount.name + ", folder " + mRemotePath + ": " + result.getLogMessage(), result.getException()); + Log_OC.e(TAG, "Checked " + mAccount.name + remotePath + " : " + result.getLogMessage(), result.getException()); } else { - Log_OC.e(TAG, "Synchroned " + mAccount.name + ", folder " + mRemotePath + ": " + result.getLogMessage()); + Log_OC.e(TAG, "Checked " + mAccount.name + remotePath + " : " + result.getLogMessage()); } } - if (!mSyncFullAccount) { - sendStickyBroadcast(false, mRemotePath, result); - } } + return result; + } + + private RemoteOperationResult fetchAndSyncRemoteFolder(WebdavClient client) { + String remotePath = mLocalFolder.getRemotePath(); + ReadRemoteFolderOperation operation = new ReadRemoteFolderOperation(remotePath); + RemoteOperationResult result = operation.execute(client); + Log_OC.d(TAG, "Synchronizing " + mAccount.name + remotePath); + + if (result.isSuccess()) { + synchronizeData(result.getData(), client); + if (mConflictsFound > 0 || mFailsInFavouritesFound > 0) { + result = new RemoteOperationResult(ResultCode.SYNC_CONFLICT); // should be different result, but will do the job + } + } else { + if (result.getCode() == ResultCode.FILE_NOT_FOUND) + removeLocalFolder(); + } + return result; } + + private void removeLocalFolder() { + if (mStorageManager.fileExists(mLocalFolder.getFileId())) { + String currentSavePath = FileStorageUtils.getSavePath(mAccount.name); + mStorageManager.removeFolder(mLocalFolder, true, (mLocalFolder.isDown() && mLocalFolder.getStoragePath().startsWith(currentSavePath))); + } + } + + + /** + * Synchronizes the data retrieved from the server about the contents of the target folder + * with the current data in the local database. + * + * Grants that mChildren is updated with fresh data after execution. + * + * @param folderAndFiles Remote folder and children files in Folder + * + * @param client Client instance to the remote server where the data were + * retrieved. + * @return 'True' when any change was made in the local data, 'false' otherwise. + */ + private void synchronizeData(ArrayList folderAndFiles, WebdavClient client) { + // get 'fresh data' from the database + mLocalFolder = mStorageManager.getFileByPath(mLocalFolder.getRemotePath()); + + // parse data from remote folder + OCFile remoteFolder = fillOCFile(folderAndFiles.get(0)); + remoteFolder.setParentId(mLocalFolder.getParentId()); + remoteFolder.setFileId(mLocalFolder.getFileId()); + + Log_OC.d(TAG, "Remote folder " + mLocalFolder.getRemotePath() + " changed - starting update of local data "); + + List updatedFiles = new Vector(folderAndFiles.size() - 1); + List filesToSyncContents = new Vector(); + + // get current data about local contents of the folder to synchronize + List localFiles = mStorageManager.getFolderContent(mLocalFolder); + Map localFilesMap = new HashMap(localFiles.size()); + for (OCFile file : localFiles) { + localFilesMap.put(file.getRemotePath(), file); + } + + // loop to update every child + OCFile remoteFile = null, localFile = null; + for (int i=1; i filesToSyncContents, WebdavClient client) { + RemoteOperationResult contentsResult = null; + for (SynchronizeFileOperation op: filesToSyncContents) { + contentsResult = op.execute(client); // returns without waiting for upload or download finishes + if (!contentsResult.isSuccess()) { + if (contentsResult.getCode() == ResultCode.SYNC_CONFLICT) { + mConflictsFound++; + } else { + mFailsInFavouritesFound++; + if (contentsResult.getException() != null) { + Log_OC.e(TAG, "Error while synchronizing favourites : " + contentsResult.getLogMessage(), contentsResult.getException()); + } else { + Log_OC.e(TAG, "Error while synchronizing favourites : " + contentsResult.getLogMessage()); + } + } + } // won't let these fails break the synchronization process + } + } + public boolean isMultiStatus(int status) { return (status == HttpStatus.SC_MULTI_STATUS); } - + /** * Creates and populates a new {@link OCFile} object with the data read from the server. * @@ -346,10 +411,25 @@ public class SynchronizeFolderOperation extends RemoteOperation { file.setFileLength(we.contentLength()); file.setMimetype(we.contentType()); file.setModificationTimestamp(we.modifiedTimestamp()); - file.setParentId(mParentId); file.setEtag(we.etag()); return file; } + + /** + * Creates and populates a new {@link OCFile} object with the data read from the server. + * + * @param remote remote file read from the server (remote file or folder). + * @return New OCFile instance representing the remote resource described by we. + */ + private OCFile fillOCFile(RemoteFile remote) { + OCFile file = new OCFile(remote.getRemotePath()); + file.setCreationTimestamp(remote.getCreationTimestamp()); + file.setFileLength(remote.getLength()); + file.setMimetype(remote.getMimeType()); + file.setModificationTimestamp(remote.getModifiedTimestamp()); + file.setEtag(remote.getEtag()); + return file; + } /** @@ -416,13 +496,31 @@ public class SynchronizeFolderOperation extends RemoteOperation { } /** + * Scans the default location for saving local copies of files searching for + * a 'lost' file with the same full name as the {@link OCFile} received as + * parameter. + * + * @param file File to associate a possible 'lost' local file. + */ + private void searchForLocalFileInDefaultPath(OCFile file) { + if (file.getStoragePath() == null && !file.isFolder()) { + File f = new File(FileStorageUtils.getDefaultSavePathFor(mAccount.name, file)); + if (f.exists()) { + file.setStoragePath(f.getAbsolutePath()); + file.setLastSyncDateForData(f.lastModified()); + } + } + } + + + /** * Sends a message to any application component interested in the progress of the synchronization. * * @param inProgress 'True' when the synchronization progress is not finished. * @param dirRemotePath Remote path of a folder that was just synchronized (with or without success) */ private void sendStickyBroadcast(boolean inProgress, String dirRemotePath, RemoteOperationResult result) { - Intent i = new Intent(FileSyncService.SYNC_MESSAGE); + Intent i = new Intent(FileSyncService.getSyncMessage()); i.putExtra(FileSyncService.IN_PROGRESS, inProgress); i.putExtra(FileSyncService.ACCOUNT_NAME, mAccount.name); if (dirRemotePath != null) { @@ -434,4 +532,9 @@ public class SynchronizeFolderOperation extends RemoteOperation { mContext.sendStickyBroadcast(i); } + + public boolean getRemoteFolderChanged() { + return mRemoteFolderChanged; + } + }