X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/1dc21189349224779d09decb886280a69af8d09a..cc77ea37de47ecf8d0261978aa9de924c917deec:/src/com/owncloud/android/operations/SynchronizeFileOperation.java diff --git a/src/com/owncloud/android/operations/SynchronizeFileOperation.java b/src/com/owncloud/android/operations/SynchronizeFileOperation.java index 6a79e751..72cb22be 100644 --- a/src/com/owncloud/android/operations/SynchronizeFileOperation.java +++ b/src/com/owncloud/android/operations/SynchronizeFileOperation.java @@ -1,6 +1,6 @@ /* ownCloud Android client application * Copyright (C) 2012 Bartek Przybylski - * Copyright (C) 2012-2013 ownCloud Inc. + * Copyright (C) 2012-2014 ownCloud Inc. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2, @@ -18,17 +18,17 @@ package com.owncloud.android.operations; -import com.owncloud.android.datamodel.FileDataStorageManager; import com.owncloud.android.datamodel.OCFile; import com.owncloud.android.files.services.FileDownloader; import com.owncloud.android.files.services.FileUploader; -import com.owncloud.android.lib.network.OwnCloudClient; -import com.owncloud.android.lib.operations.common.RemoteOperation; -import com.owncloud.android.lib.operations.common.RemoteOperationResult; -import com.owncloud.android.lib.operations.common.RemoteOperationResult.ResultCode; -import com.owncloud.android.lib.operations.remote.ReadRemoteFileOperation; +import com.owncloud.android.lib.common.OwnCloudClient; +import com.owncloud.android.lib.resources.files.RemoteFile; +import com.owncloud.android.lib.common.operations.RemoteOperationResult; +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode; +import com.owncloud.android.lib.common.utils.Log_OC; +import com.owncloud.android.lib.resources.files.ReadRemoteFileOperation; +import com.owncloud.android.operations.common.SyncOperation; import com.owncloud.android.utils.FileStorageUtils; -import com.owncloud.android.utils.Log_OC; import android.accounts.Account; import android.content.Context; @@ -41,41 +41,144 @@ import android.content.Intent; * @author masensio */ -public class SynchronizeFileOperation extends RemoteOperation { +public class SynchronizeFileOperation extends SyncOperation { private String TAG = SynchronizeFileOperation.class.getSimpleName(); private OCFile mLocalFile; + private String mRemotePath; private OCFile mServerFile; - private FileDataStorageManager mStorageManager; private Account mAccount; private boolean mSyncFileContents; private Context mContext; private boolean mTransferWasRequested = false; + + /** + * When 'false', uploads to the server are not done; only downloads or conflict detection. + * This is a temporal field. + * TODO Remove when 'folder synchronization' replaces 'folder download'. + */ + private boolean mAllowUploads; + + /** + * Constructor for "full synchronization mode". + * + * Uses remotePath to retrieve all the data both in local cache and in the remote OC server when the operation + * is executed, instead of reusing {@link OCFile} instances. + * + * Useful for direct synchronization of a single file. + * + * @param + * @param account ownCloud account holding the file. + * @param syncFileContents When 'true', transference of data will be started by the + * operation if needed and no conflict is detected. + * @param context Android context; needed to start transfers. + */ + public SynchronizeFileOperation( + String remotePath, + Account account, + boolean syncFileContents, + Context context) { + + mRemotePath = remotePath; + mLocalFile = null; + mServerFile = null; + mAccount = account; + mSyncFileContents = syncFileContents; + mContext = context; + mAllowUploads = true; + } + + + /** + * Constructor allowing to reuse {@link OCFile} instances just queried from local cache or from remote OC server. + * + * Useful to include this operation as part of the synchronization of a folder (or a full account), avoiding the + * repetition of fetch operations (both in local database or remote server). + * + * At least one of localFile or serverFile MUST NOT BE NULL. If you don't have none of them, use the other + * constructor. + * + * @param localFile Data of file (just) retrieved from local cache/database. + * @param serverFile Data of file (just) retrieved from a remote server. If null, will be + * retrieved from network by the operation when executed. + * @param account ownCloud account holding the file. + * @param syncFileContents When 'true', transference of data will be started by the + * operation if needed and no conflict is detected. + * @param context Android context; needed to start transfers. + */ public SynchronizeFileOperation( OCFile localFile, - OCFile serverFile, // make this null to let the operation checks the server; added to reuse info from SynchronizeFolderOperation - FileDataStorageManager storageManager, + OCFile serverFile, Account account, boolean syncFileContents, Context context) { mLocalFile = localFile; mServerFile = serverFile; - mStorageManager = storageManager; + if (mLocalFile != null) { + mRemotePath = mLocalFile.getRemotePath(); + if (mServerFile != null && !mServerFile.getRemotePath().equals(mRemotePath)) { + throw new IllegalArgumentException("serverFile and localFile do not correspond to the same OC file"); + } + } else if (mServerFile != null) { + mRemotePath = mServerFile.getRemotePath(); + } else { + throw new IllegalArgumentException("Both serverFile and localFile are NULL"); + } mAccount = account; mSyncFileContents = syncFileContents; mContext = context; + mAllowUploads = true; } + + /** + * Temporal constructor. + * + * Extends the previous one to allow constrained synchronizations where uploads are never performed - only + * downloads or conflict detection. + * + * Do not use unless you are involved in 'folder synchronization' or 'folder download' work in progress. + * + * TODO Remove when 'folder synchronization' replaces 'folder download'. + * + * @param localFile Data of file (just) retrieved from local cache/database. MUSTN't be null. + * @param serverFile Data of file (just) retrieved from a remote server. If null, will be + * retrieved from network by the operation when executed. + * @param account ownCloud account holding the file. + * @param syncFileContents When 'true', transference of data will be started by the + * operation if needed and no conflict is detected. + * @param allowUploads When 'false', uploads to the server are not done; only downloads or conflict + * detection. + * @param context Android context; needed to start transfers. + */ + public SynchronizeFileOperation( + OCFile localFile, + OCFile serverFile, + Account account, + boolean syncFileContents, + boolean allowUploads, + Context context) { + + this(localFile, serverFile, account, syncFileContents, context); + mAllowUploads = allowUploads; + } + @Override protected RemoteOperationResult run(OwnCloudClient client) { RemoteOperationResult result = null; mTransferWasRequested = false; + + if (mLocalFile == null) { + // Get local file from the DB + mLocalFile = getStorageManager().getFileByPath(mRemotePath); + } + if (!mLocalFile.isDown()) { /// easy decision requestForDownload(mLocalFile); @@ -85,28 +188,29 @@ public class SynchronizeFileOperation extends RemoteOperation { /// local copy in the device -> need to think a bit more before do anything if (mServerFile == null) { - String remotePath = mLocalFile.getRemotePath(); - ReadRemoteFileOperation operation = new ReadRemoteFileOperation(remotePath); + ReadRemoteFileOperation operation = new ReadRemoteFileOperation(mRemotePath); result = operation.execute(client); if (result.isSuccess()){ - mServerFile = FileStorageUtils.fillOCFile(result.getData().get(0)); + mServerFile = FileStorageUtils.fillOCFile((RemoteFile) result.getData().get(0)); mServerFile.setLastSyncDateForProperties(System.currentTimeMillis()); } } - if (result.isSuccess()) { + if (mServerFile != null) { /// check changes in server and local file boolean serverChanged = false; /* time for eTag is coming, but not yet if (mServerFile.getEtag() != null) { - serverChanged = (!mServerFile.getEtag().equals(mLocalFile.getEtag())); // TODO could this be dangerous when the user upgrades the server from non-tagged to tagged? + serverChanged = (!mServerFile.getEtag().equals(mLocalFile.getEtag())); } else { */ - // server without etags - serverChanged = (mServerFile.getModificationTimestamp() != mLocalFile.getModificationTimestampAtLastSyncForData()); + serverChanged = ( + mServerFile.getModificationTimestamp() != mLocalFile.getModificationTimestampAtLastSyncForData() + ); //} - boolean localChanged = (mLocalFile.getLocalModificationTimestamp() > mLocalFile.getLastSyncDateForData()); - // TODO this will be always true after the app is upgraded to database version 2; will result in unnecessary uploads + boolean localChanged = ( + mLocalFile.getLocalModificationTimestamp() > mLocalFile.getLastSyncDateForData() + ); /// decide action to perform depending upon changes //if (!mLocalFile.getEtag().isEmpty() && localChanged && serverChanged) { @@ -114,7 +218,7 @@ public class SynchronizeFileOperation extends RemoteOperation { result = new RemoteOperationResult(ResultCode.SYNC_CONFLICT); } else if (localChanged) { - if (mSyncFileContents) { + if (mSyncFileContents && mAllowUploads) { requestForUpload(mLocalFile); // the local update of file properties will be done by the FileUploader service when the upload finishes } else { @@ -125,6 +229,8 @@ public class SynchronizeFileOperation extends RemoteOperation { result = new RemoteOperationResult(ResultCode.OK); } else if (serverChanged) { + mLocalFile.setRemoteId(mServerFile.getRemoteId()); + if (mSyncFileContents) { requestForDownload(mLocalFile); // local, not server; we won't to keep the value of keepInSync! // the update of local data will be done later by the FileUploader service when the upload finishes @@ -134,7 +240,7 @@ public class SynchronizeFileOperation extends RemoteOperation { mServerFile.setLastSyncDateForData(mLocalFile.getLastSyncDateForData()); mServerFile.setStoragePath(mLocalFile.getStoragePath()); mServerFile.setParentId(mLocalFile.getParentId()); - mStorageManager.saveFile(mServerFile); + getStorageManager().saveFile(mServerFile); } result = new RemoteOperationResult(ResultCode.OK); @@ -148,7 +254,8 @@ public class SynchronizeFileOperation extends RemoteOperation { } - Log_OC.i(TAG, "Synchronizing " + mAccount.name + ", file " + mLocalFile.getRemotePath() + ": " + result.getLogMessage()); + Log_OC.i(TAG, "Synchronizing " + mAccount.name + ", file " + mLocalFile.getRemotePath() + ": " + + result.getLogMessage()); return result; }