<string name="sync_foreign_files_forgotten_ticker">Some local files were forgotten</string>
<string name="sync_foreign_files_forgotten_content">%1$d files out of the %2$s directory could not be copied into</string>
<string name="sync_foreign_files_forgotten_explanation">As of version 1.3.16, files uploaded from this device are copied into the local %1$s folder to prevent data loss when a single file is synced with multiple accounts.\n\nDue to this change, all files uploaded in previous versions of this app were copied into the %2$s folder. However, an error prevented the completion of this operation during account synchronization. You may either leave the file(s) as is and remove the link to %3$s, or move the file(s) into the %1$s directory and retain the link to %4$s.\n\nListed below are the local file(s), and the the remote file(s) in %5$s they were linked to.</string>
+ <string name="sync_current_folder_was_removed">Current folder does not exist</string>
<string name="foreign_files_move">"Move all"</string>
<string name="foreign_files_success">"All files were moved"</string>
<string name="foreign_files_fail">"Some files could not be moved"</string>
cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, file.getFileLength());
cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, file.getMimetype());
cv.put(ProviderTableMeta.FILE_NAME, file.getFileName());
- if (file.getParentId() != 0)
+ //if (file.getParentId() != DataStorageManager.ROOT_PARENT_ID)
cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
cv.put(ProviderTableMeta.FILE_PATH, file.getRemotePath());
if (!file.isDirectory())
cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, file.getLastSyncDateForProperties());
cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, file.getLastSyncDateForData());
cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, file.keepInSync() ? 1 : 0);
+ cv.put(ProviderTableMeta.FILE_ETAG, file.getEtag());
boolean sameRemotePath = fileExists(file.getRemotePath());
boolean changesSizeOfAncestors = false;
cv.put(ProviderTableMeta.FILE_CONTENT_LENGTH, file.getFileLength());
cv.put(ProviderTableMeta.FILE_CONTENT_TYPE, file.getMimetype());
cv.put(ProviderTableMeta.FILE_NAME, file.getFileName());
- if (file.getParentId() != 0)
+ if (file.getParentId() != DataStorageManager.ROOT_PARENT_ID)
cv.put(ProviderTableMeta.FILE_PARENT, file.getParentId());
cv.put(ProviderTableMeta.FILE_PATH, file.getRemotePath());
if (!file.isDirectory())
cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE, file.getLastSyncDateForProperties());
cv.put(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA, file.getLastSyncDateForData());
cv.put(ProviderTableMeta.FILE_KEEP_IN_SYNC, file.keepInSync() ? 1 : 0);
+ cv.put(ProviderTableMeta.FILE_ETAG, file.getEtag());
if (fileExists(file.getRemotePath())) {
OCFile oldFile = getFileByPath(file.getRemotePath());
getColumnIndex(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA)));
file.setKeepInSync(c.getInt(
c.getColumnIndex(ProviderTableMeta.FILE_KEEP_IN_SYNC)) == 1 ? true : false);
+ file.setEtag(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_ETAG)));
+
}
return file;
}
OCFile file;
- while (parentId != 0) {
+ while (parentId != DataStorageManager.ROOT_PARENT_ID) {
// Update the size of the parent
calculateFolderSize(parentId);
private String mEtag;
+
/**
* Create new {@link OCFile} with given path.
*
mKeepInSync = source.readInt() == 1;
mLastSyncDateForProperties = source.readLong();
mLastSyncDateForData = source.readLong();
+ mEtag = source.readString();
}
@Override
dest.writeInt(mKeepInSync ? 1 : 0);
dest.writeLong(mLastSyncDateForProperties);
dest.writeLong(mLastSyncDateForData);
+ dest.writeString(mEtag);
}
/**
mLastSyncDateForData = 0;
mKeepInSync = false;
mNeedsUpdating = false;
+ mEtag = null;
}
/**
@Override
public String toString() {
- String asString = "[id=%s, name=%s, mime=%s, downloaded=%s, local=%s, remote=%s, parentId=%s, keepInSinc=%s]";
- asString = String.format(asString, Long.valueOf(mId), getFileName(), mMimeType, isDown(), mLocalPath, mRemotePath, Long.valueOf(mParentId), Boolean.valueOf(mKeepInSync));
+ String asString = "[id=%s, name=%s, mime=%s, downloaded=%s, local=%s, remote=%s, parentId=%s, keepInSinc=%s etag=%s]";
+ asString = String.format(asString, Long.valueOf(mId), getFileName(), mMimeType, isDown(), mLocalPath, mRemotePath, Long.valueOf(mParentId), Boolean.valueOf(mKeepInSync), mEtag);
return asString;
}
return mEtag;
}
+ public void setEtag(String etag) {
+ this.mEtag = etag;
+ }
+
public long getLocalModificationTimestamp() {
if (mLocalPath != null && mLocalPath.length() > 0) {
File f = new File(mLocalPath);
public static final String AUTHORITY_FILES = "org.owncloud";\r
public static final String DB_FILE = "owncloud.db";\r
public static final String DB_NAME = "filelist";\r
- public static final int DB_VERSION = 4;\r
+ public static final int DB_VERSION = 5;\r
\r
private ProviderMeta() {\r
}\r
public static final String FILE_LAST_SYNC_DATE = "last_sync_date"; // _for_properties, but let's keep it as it is\r
public static final String FILE_LAST_SYNC_DATE_FOR_DATA = "last_sync_date_for_data";\r
public static final String FILE_KEEP_IN_SYNC = "keep_in_sync";\r
+ public static final String FILE_ETAG = "etag";\r
\r
public static final String DEFAULT_SORT_ORDER = FILE_NAME\r
+ " collate nocase asc";\r
mCallerActivity = callerActivity;
mClient = null; // the client instance will be created from mAccount and mContext in the runnerThread to create below
- if (listener == null) {
- throw new IllegalArgumentException("Trying to execute a remote operation asynchronously without a listener to notiy the result");
- }
mListener = listener;
- if (listenerHandler == null) {
- throw new IllegalArgumentException("Trying to execute a remote operation asynchronously without a handler to the listener's thread");
- }
mListenerHandler = listenerHandler;
Thread runnerThread = new Thread(this);
OK,
OK_SSL,
OK_NO_SSL,
+ OK_NO_CHANGES_ON_DIR,
UNHANDLED_HTTP_CODE,
UNAUTHORIZED,
FILE_NOT_FOUND,
public RemoteOperationResult(ResultCode code) {
mCode = code;
- mSuccess = (code == ResultCode.OK || code == ResultCode.OK_SSL || code == ResultCode.OK_NO_SSL);
+ mSuccess = (code == ResultCode.OK || code == ResultCode.OK_SSL || code == ResultCode.OK_NO_SSL || code == ResultCode.OK_NO_CHANGES_ON_DIR);
}
private RemoteOperationResult(boolean success, int httpCode) {
file.setFileLength(we.contentLength());
file.setMimetype(we.contentType());
file.setModificationTimestamp(we.modifiedTimestamp());
+ file.setEtag(we.etag());
+
return file;
}
import java.util.Map;
import java.util.Vector;
-import org.apache.commons.httpclient.Header;
import org.apache.http.HttpStatus;
import org.apache.jackrabbit.webdav.MultiStatus;
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.OCFile;
import com.owncloud.android.operations.RemoteOperationResult.ResultCode;
+import com.owncloud.android.syncadapter.FileSyncService;
import com.owncloud.android.utils.FileStorageUtils;
import eu.alefzero.webdav.WebdavClient;
/**
- * 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;
+ /** 'True' means that the properties of the folder should be updated also, not just its content */
+ private boolean mUpdateFolderProperties;
+
/** Access to the local database */
private DataStorageManager 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<OCFile> 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<String, String> mForgottenLocalFiles;
+
+ /** 'True' means that this operation is part of a full account synchronization */
+ private boolean mSyncFullAccount;
- 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 updateFolderProperties,
+ boolean syncFullAccount,
DataStorageManager dataStorageManager,
Account account,
Context context ) {
- mRemotePath = remotePath;
+ mLocalFolder = folder;
mCurrentSyncTime = currentSyncTime;
- mParentId = parentId;
+ mUpdateFolderProperties = updateFolderProperties;
+ mSyncFullAccount = syncFullAccount;
mStorageManager = dataStorageManager;
mAccount = account;
mContext = context;
/**
* 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<OCFile> getChildren() {
return mChildren;
}
-
+ /**
+ * Performs the synchronization.
+ *
+ * {@inheritDoc}
+ */
@Override
protected RemoteOperationResult run(WebdavClient client) {
RemoteOperationResult result = null;
mFailsInFavouritesFound = 0;
mConflictsFound = 0;
mForgottenLocalFiles.clear();
-
- // code before in FileSyncAdapter.fetchData
+ 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, "Synchronizing " + mAccount.name + remotePath);
+
// remote request
- query = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(mRemotePath));
+ query = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(remotePath));
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
- if (mParentId == DataStorageManager.ROOT_PARENT_ID) {
- WebdavEntry we = new WebdavEntry(resp.getResponses()[0], client.getBaseUri().getPath());
- OCFile parent = fillOCFile(we);
- mStorageManager.saveFile(parent);
- mParentId = parent.getFileId();
- }
-
- // read contents in folder
- List<OCFile> updatedFiles = new Vector<OCFile>(resp.getResponses().length - 1);
- List<SynchronizeFileOperation> filesToSyncContents = new Vector<SynchronizeFileOperation>();
- for (int i = 1; i < resp.getResponses().length; ++i) {
- /// new OCFile instance with the data from the server
- WebdavEntry we = new WebdavEntry(resp.getResponses()[i], client.getBaseUri().getPath());
- OCFile file = fillOCFile(we);
-
- /// set data about local state, keeping unchanged former data if existing
- file.setLastSyncDateForProperties(mCurrentSyncTime);
- OCFile oldFile = mStorageManager.getFileByPath(file.getRemotePath());
- 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());
- }
-
- /// 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
- SynchronizeFileOperation op = null;
- RemoteOperationResult contentsResult = null;
- for (int i=0; i < filesToSyncContents.size(); i++) {
- op = filesToSyncContents.get(i);
- 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);
+ // check and process response
+ if (isMultiStatus(status)) {
+ boolean folderChanged = synchronizeData(query.getResponseBodyAsMultiStatus(), client);
+ if (folderChanged) {
+ if (mConflictsFound > 0 || mFailsInFavouritesFound > 0) {
+ result = new RemoteOperationResult(ResultCode.SYNC_CONFLICT); // should be different result, but will do the job
} else {
- i++;
+ result = new RemoteOperationResult(true, status, query.getResponseHeaders());
}
+ } else {
+ result = new RemoteOperationResult(ResultCode.OK_NO_CHANGES_ON_DIR);
}
} else {
+ // synchronization failed
client.exhaustResponse(query.getResponseBodyAsStream());
- }
-
- // prepare result object
- if (isMultiStatus(status)) {
- 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());
+ if (status == HttpStatus.SC_NOT_FOUND) {
+ if (mStorageManager.fileExists(mLocalFolder.getFileId())) {
+ String currentSavePath = FileStorageUtils.getSavePath(mAccount.name);
+ mStorageManager.removeDirectory(mLocalFolder, true, (mLocalFolder.isDown() && mLocalFolder.getStoragePath().startsWith(currentSavePath)));
+ }
}
- } else {
result = new RemoteOperationResult(false, status, query.getResponseHeaders());
}
-
-
-
+
} catch (Exception e) {
result = new RemoteOperationResult(e);
if (query != null)
query.releaseConnection(); // let the connection available for other methods
if (result.isSuccess()) {
- Log_OC.i(TAG, "Synchronizing " + mAccount.name + ", folder " + mRemotePath + ": " + result.getLogMessage());
+ Log_OC.i(TAG, "Synchronized " + mAccount.name + remotePath + ": " + result.getLogMessage());
} else {
if (result.isException()) {
- Log_OC.e(TAG, "Synchronizing " + mAccount.name + ", folder " + mRemotePath + ": " + result.getLogMessage(), result.getException());
+ Log_OC.e(TAG, "Synchroned " + mAccount.name + remotePath + ": " + result.getLogMessage(), result.getException());
} else {
- Log_OC.e(TAG, "Synchronizing " + mAccount.name + ", folder " + mRemotePath + ": " + result.getLogMessage());
+ Log_OC.e(TAG, "Synchroned " + mAccount.name + remotePath + ": " + result.getLogMessage());
}
}
+
+ if (!mSyncFullAccount) {
+ sendStickyBroadcast(false, remotePath, result);
+ }
}
-
+
return result;
}
-
+
+
+ /**
+ * 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 dataInServer Full response got from the server with the data of the target
+ * folder and its direct children.
+ * @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 boolean synchronizeData(MultiStatus dataInServer, WebdavClient client) {
+ // get 'fresh data' from the database
+ mLocalFolder = mStorageManager.getFileById(mLocalFolder.getFileId());
+
+ // parse data from remote folder
+ WebdavEntry we = new WebdavEntry(dataInServer.getResponses()[0], client.getBaseUri().getPath());
+ OCFile remoteFolder = fillOCFile(we);
+ remoteFolder.setParentId(mLocalFolder.getParentId());
+ remoteFolder.setFileId(mLocalFolder.getFileId());
+
+ // check if remote and local folder are different
+ boolean folderChanged = !(remoteFolder.getEtag().equalsIgnoreCase(mLocalFolder.getEtag()));
+
+ if (!folderChanged) {
+ if (mUpdateFolderProperties) { // TODO check if this is really necessary
+ mStorageManager.saveFile(remoteFolder);
+ }
+
+ mChildren = mStorageManager.getDirectoryContent(mLocalFolder);
+
+ } else {
+ // read info of folder contents
+ List<OCFile> updatedFiles = new Vector<OCFile>(dataInServer.getResponses().length - 1);
+ List<SynchronizeFileOperation> filesToSyncContents = new Vector<SynchronizeFileOperation>();
+
+ // loop to update every child
+ OCFile remoteFile = null, localFile = null;
+ for (int i = 1; i < dataInServer.getResponses().length; ++i) {
+ /// new OCFile instance with the data from the server
+ we = new WebdavEntry(dataInServer.getResponses()[i], client.getBaseUri().getPath());
+ remoteFile = fillOCFile(we);
+ remoteFile.setParentId(mLocalFolder.getFileId());
+
+ /// retrieve local data for the read file
+ localFile = mStorageManager.getFileByPath(remoteFile.getRemotePath());
+
+ /// add to the remoteFile (the new one) data about LOCAL STATE (not existing in the server side)
+ remoteFile.setLastSyncDateForProperties(mCurrentSyncTime);
+ if (localFile != null) {
+ // properties of local state are kept unmodified
+ remoteFile.setKeepInSync(localFile.keepInSync());
+ remoteFile.setLastSyncDateForData(localFile.getLastSyncDateForData());
+ remoteFile.setModificationTimestampAtLastSyncForData(localFile.getModificationTimestampAtLastSyncForData());
+ remoteFile.setStoragePath(localFile.getStoragePath());
+ remoteFile.setEtag(localFile.getEtag()); // eTag will not be updated unless contents are synchronized (Synchronize[File|Folder]Operation with remoteFile as parameter)
+ } else {
+ remoteFile.setEtag(""); // remote eTag will not be updated unless contents are synchronized (Synchronize[File|Folder]Operation with remoteFile as parameter)
+ }
+
+ /// check and fix, if need, local storage path
+ checkAndFixForeignStoragePath(remoteFile); // fixing old policy - now local files must be copied into the ownCloud local folder
+ searchForLocalFileInDefaultPath(remoteFile); // legacy
+
+ /// prepare content synchronization for kept-in-sync files
+ if (remoteFile.keepInSync()) {
+ SynchronizeFileOperation operation = new SynchronizeFileOperation( localFile,
+ remoteFile,
+ mStorageManager,
+ mAccount,
+ true,
+ false,
+ mContext
+ );
+ filesToSyncContents.add(operation);
+ }
+
+ updatedFiles.add(remoteFile);
+ }
+
+ // 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 file contents AFTER saving current remote properties
+ startContentSynchronizations(filesToSyncContents, client);
+
+ // removal of obsolete files
+ removeObsoleteFiles();
+
+ // must be done AFTER saving all the children information, so that eTag is not updated in the database in case of unexpected exceptions
+ mStorageManager.saveFile(remoteFolder);
+
+ }
+
+ return folderChanged;
+
+ }
+
+
+ /**
+ * Removes obsolete children in the folder after saving all the new data.
+ */
+ private void removeObsoleteFiles() {
+ mChildren = mStorageManager.getDirectoryContent(mLocalFolder);
+ 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++;
+ }
+ }
+ }
+
+
+ /**
+ * Performs a list of synchronization operations, determining if a download or upload is needed or
+ * if exists conflict due to changes both in local and remote contents of the each file.
+ *
+ * If download or upload is needed, request the operation to the corresponding service and goes on.
+ *
+ * @param filesToSyncContents Synchronization operations to execute.
+ * @param client Interface to the remote ownCloud server.
+ */
+ private void startContentSynchronizations(List<SynchronizeFileOperation> 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);
file.setFileLength(we.contentLength());
file.setMimetype(we.contentType());
file.setModificationTimestamp(we.modifiedTimestamp());
- file.setParentId(mParentId);
+ file.setEtag(we.etag());
return file;
}
*
* 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) {
}
+ /**
+ * 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.isDirectory()) {
+ 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);
+ i.putExtra(FileSyncService.IN_PROGRESS, inProgress);
+ i.putExtra(FileSyncService.ACCOUNT_NAME, mAccount.name);
+ if (dirRemotePath != null) {
+ i.putExtra(FileSyncService.SYNC_FOLDER_REMOTE_PATH, dirRemotePath);
+ }
+ if (result != null) {
+ i.putExtra(FileSyncService.SYNC_RESULT, result);
+ }
+ mContext.sendStickyBroadcast(i);
+ }
+
}
ProviderTableMeta.FILE_KEEP_IN_SYNC);
mProjectionMap.put(ProviderTableMeta.FILE_ACCOUNT_OWNER,
ProviderTableMeta.FILE_ACCOUNT_OWNER);
+ mProjectionMap.put(ProviderTableMeta.FILE_ETAG,
+ ProviderTableMeta.FILE_ETAG);
}
private static final int SINGLE_FILE = 1;
+ ProviderTableMeta.FILE_LAST_SYNC_DATE + " INTEGER, "
+ ProviderTableMeta.FILE_KEEP_IN_SYNC + " INTEGER, "
+ ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA + " INTEGER, "
- + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " INTEGER );"
+ + ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA + " INTEGER, "
+ + ProviderTableMeta.FILE_ETAG + " TEXT );"
);
}
}
if (!upgraded)
Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
+
+ if (oldVersion < 5 && newVersion >= 5) {
+ Log_OC.i("SQL", "Entering in the #4 ADD in onUpgrade");
+ db.beginTransaction();
+ try {
+ db .execSQL("ALTER TABLE " + ProviderTableMeta.DB_NAME +
+ " ADD COLUMN " + ProviderTableMeta.FILE_ETAG + " TEXT " +
+ " DEFAULT NULL");
+
+ upgraded = true;
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ }
+ if (!upgraded)
+ Log_OC.i("SQL", "OUT of the ADD in onUpgrade; oldVersion == " + oldVersion + ", newVersion == " + newVersion);
}
-
}
}
package com.owncloud.android.syncadapter;\r
\r
import java.io.IOException;\r
-import java.net.UnknownHostException;\r
-import java.util.Date;\r
+//import java.net.UnknownHostException;\r
+//import java.util.Date;\r
\r
import org.apache.http.HttpRequest;\r
import org.apache.http.HttpResponse;\r
import org.apache.http.client.ClientProtocolException;\r
-import org.apache.http.conn.ConnectionKeepAliveStrategy;\r
-import org.apache.http.protocol.HttpContext;\r
+//import org.apache.http.conn.ConnectionKeepAliveStrategy;\r
+//import org.apache.http.protocol.HttpContext;\r
\r
import com.owncloud.android.authentication.AccountUtils;\r
import com.owncloud.android.authentication.AccountUtils.AccountNotFoundException;\r
import eu.alefzero.webdav.WebdavClient;\r
\r
/**\r
- * Base SyncAdapter for OwnCloud Designed to be subclassed for the concrete\r
- * SyncAdapter, like ConcatsSync, CalendarSync, FileSync etc..\r
+ * Base synchronization adapter for ownCloud designed to be subclassed for different\r
+ * resource types, like FileSync, ConcatsSync, CalendarSync, etc..\r
* \r
- * @author sassman\r
+ * Implements the standard {@link AbstractThreadedSyncAdapter}.\r
* \r
+ * @author sassman\r
+ * @author David A. Velasco\r
*/\r
public abstract class AbstractOwnCloudSyncAdapter extends\r
AbstractThreadedSyncAdapter {\r
private AccountManager accountManager;\r
private Account account;\r
private ContentProviderClient contentProvider;\r
- private Date lastUpdated;\r
+ //private Date lastUpdated;\r
private DataStorageManager mStoreManager;\r
\r
private WebdavClient mClient = null;\r
this.contentProvider = contentProvider;\r
}\r
\r
- public Date getLastUpdated() {\r
- return lastUpdated;\r
- }\r
-\r
- public void setLastUpdated(Date lastUpdated) {\r
- this.lastUpdated = lastUpdated;\r
- }\r
-\r
public void setStorageManager(DataStorageManager storage_manager) {\r
mStoreManager = storage_manager;\r
}\r
return mStoreManager;\r
}\r
\r
+ protected void initClientForCurrentAccount() throws OperationCanceledException, AuthenticatorException, IOException, AccountNotFoundException {\r
+ AccountUtils.constructFullURLForAccount(getContext(), account);\r
+ mClient = OwnCloudClientUtils.createOwnCloudClient(account, getContext());\r
+ }\r
+ \r
+ protected WebdavClient getClient() {\r
+ return mClient;\r
+ }\r
+ \r
+ \r
+ /* method called by ContactSyncAdapter, that is never used */\r
+ protected HttpResponse fireRawRequest(HttpRequest query)\r
+ throws ClientProtocolException, OperationCanceledException,\r
+ AuthenticatorException, IOException {\r
+ /*\r
+ * BasicHttpContext httpContext = new BasicHttpContext(); BasicScheme\r
+ * basicAuth = new BasicScheme();\r
+ * httpContext.setAttribute("preemptive-auth", basicAuth);\r
+ * \r
+ * HttpResponse response = getClient().execute(mHost, query,\r
+ * httpContext);\r
+ */\r
+ return null;\r
+ }\r
+\r
+ /* methods never used below */\r
+ /*\r
+ public Date getLastUpdated() {\r
+ return lastUpdated;\r
+ }\r
+\r
+ public void setLastUpdated(Date lastUpdated) {\r
+ this.lastUpdated = lastUpdated;\r
+ }\r
+\r
protected ConnectionKeepAliveStrategy getKeepAliveStrategy() {\r
return new ConnectionKeepAliveStrategy() {\r
public long getKeepAliveDuration(HttpResponse response,\r
}\r
};\r
}\r
-\r
- protected HttpResponse fireRawRequest(HttpRequest query)\r
- throws ClientProtocolException, OperationCanceledException,\r
- AuthenticatorException, IOException {\r
- /*\r
- * BasicHttpContext httpContext = new BasicHttpContext(); BasicScheme\r
- * basicAuth = new BasicScheme();\r
- * httpContext.setAttribute("preemptive-auth", basicAuth);\r
- * \r
- * HttpResponse response = getClient().execute(mHost, query,\r
- * httpContext);\r
- */\r
- return null;\r
- }\r
-\r
- protected void initClientForCurrentAccount() throws OperationCanceledException, AuthenticatorException, IOException, AccountNotFoundException {\r
- AccountUtils.constructFullURLForAccount(getContext(), account);\r
- mClient = OwnCloudClientUtils.createOwnCloudClient(account, getContext());\r
- }\r
- \r
- protected WebdavClient getClient() {\r
- return mClient;\r
- }\r
+ */\r
}
\ No newline at end of file
import com.owncloud.android.R;
import com.owncloud.android.authentication.AccountAuthenticator;
import com.owncloud.android.authentication.AuthenticatorActivity;
-import com.owncloud.android.datamodel.DataStorageManager;
import com.owncloud.android.datamodel.FileDataStorageManager;
import com.owncloud.android.datamodel.OCFile;
import com.owncloud.android.operations.RemoteOperationResult;
import com.owncloud.android.operations.UpdateOCVersionOperation;
import com.owncloud.android.operations.RemoteOperationResult.ResultCode;
import com.owncloud.android.ui.activity.ErrorsWhileCopyingHandlerActivity;
-import com.owncloud.android.utils.FileStorageUtils;
import android.accounts.Account;
import android.accounts.AccountsException;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
+import android.content.AbstractThreadedSyncAdapter;
import android.content.ContentProviderClient;
import android.content.ContentResolver;
import android.content.Context;
import android.os.Bundle;
/**
- * SyncAdapter implementation for syncing sample SyncAdapter contacts to the
- * platform ContactOperations provider.
+ * Implementation of {@link AbstractThreadedSyncAdapter} responsible for synchronizing
+ * ownCloud files.
+ *
+ * Performs a full synchronization of the account recieved in {@link #onPerformSync(Account, Bundle, String, ContentProviderClient, SyncResult)}.
*
* @author Bartek Przybylski
* @author David A. Velasco
*/
public class FileSyncAdapter extends AbstractOwnCloudSyncAdapter {
- private final static String TAG = "FileSyncAdapter";
+ private final static String TAG = FileSyncAdapter.class.getSimpleName();
- /**
- * Maximum number of failed folder synchronizations that are supported before finishing the synchronization operation
- */
+ /** Maximum number of failed folder synchronizations that are supported before finishing the synchronization operation */
private static final int MAX_FAILED_RESULTS = 3;
+
+ /** Time stamp for the current synchronization process, used to distinguish fresh data */
private long mCurrentSyncTime;
+
+ /** Flag made 'true' when a request to cancel the synchronization is received */
private boolean mCancellation;
+
+ /** When 'true' the process was requested by the user through the user interface; when 'false', it was requested automatically by the system */
private boolean mIsManualSync;
- private int mFailedResultsCounter;
+
+ /** Counter for failed operations in the synchronization process */
+ private int mFailedResultsCounter;
+
+ /** Result of the last failed operation */
private RemoteOperationResult mLastFailedResult;
- private SyncResult mSyncResult;
+
+ /** 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<String, String> mForgottenLocalFiles;
+ /** {@link SyncResult} instance to return to the system when the synchronization finish */
+ private SyncResult mSyncResult;
+
+ /**
+ * Creates an {@link FileSyncAdapter}
+ *
+ * {@inheritDoc}
+ */
public FileSyncAdapter(Context context, boolean autoInitialize) {
super(context, autoInitialize);
}
+
/**
* {@inheritDoc}
*/
mForgottenLocalFiles = new HashMap<String, String>();
mSyncResult = syncResult;
mSyncResult.fullSyncRequested = false;
- mSyncResult.delayUntil = 60*60*24; // sync after 24h
+ mSyncResult.delayUntil = 60*60*24; // avoid too many automatic synchronizations
this.setAccount(account);
this.setContentProvider(provider);
- this.setStorageManager(new FileDataStorageManager(account, getContentProvider()));
+ this.setStorageManager(new FileDataStorageManager(account, provider));
try {
this.initClientForCurrentAccount();
} catch (IOException e) {
- /// the account is unknown for the Synchronization Manager, or unreachable for this context; don't try this again
+ /// the account is unknown for the Synchronization Manager, unreachable this context, or can not be authenticated; don't try this again
mSyncResult.tooManyRetries = true;
notifyFailedSynchronization();
return;
} catch (AccountsException e) {
- /// the account is unknown for the Synchronization Manager, or unreachable for this context; don't try this again
+ /// the account is unknown for the Synchronization Manager, unreachable this context, or can not be authenticated; don't try this again
mSyncResult.tooManyRetries = true;
notifyFailedSynchronization();
return;
updateOCVersion();
mCurrentSyncTime = System.currentTimeMillis();
if (!mCancellation) {
- fetchData(OCFile.PATH_SEPARATOR, DataStorageManager.ROOT_PARENT_ID);
+ synchronizeFolder(getStorageManager().getFileByPath(OCFile.PATH_SEPARATOR), true);
} else {
- Log_OC.d(TAG, "Leaving synchronization before any remote request due to cancellation was requested");
+ Log_OC.d(TAG, "Leaving synchronization before synchronizing the root folder because cancelation request");
}
/// notify the user about the failure of MANUAL synchronization
notifyFailedSynchronization();
-
}
if (mConflictsFound > 0 || mFailsInFavouritesFound > 0) {
notifyFailsInFavourites();
}
if (mForgottenLocalFiles.size() > 0) {
notifyForgottenLocalFiles();
-
}
sendStickyBroadcast(false, null, mLastFailedResult); // message to signal the end to the UI
}
/**
* Called by system SyncManager when a synchronization is required to be cancelled.
*
- * Sets the mCancellation flag to 'true'. THe synchronization will be stopped when before a new folder is fetched. Data of the last folder
- * fetched will be still saved in the database. See onPerformSync implementation.
+ * Sets the mCancellation flag to 'true'. THe synchronization will be stopped later,
+ * before a new folder is fetched. Data of the last folder synchronized will be still
+ * locally saved.
+ *
+ * See {@link #onPerformSync(Account, Bundle, String, ContentProviderClient, SyncResult)}
+ * and {@link #synchronizeFolder(String, long)}.
*/
@Override
public void onSyncCanceled() {
/**
- * Synchronize the properties of files and folders contained in a remote folder given by remotePath.
+ * Synchronizes 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.
+ *
+ * Enters in the child folders to synchronize their contents also, following a recursive
+ * depth first strategy.
*
- * @param remotePath Remote path to the folder to synchronize.
- * @param parentId Database Id of the folder to synchronize.
+ * @param folder Folder to synchronize.
+ * @param updateFolderProperties When 'true', updates also the properties of the of the target folder.
*/
- private void fetchData(String remotePath, long parentId) {
+ private void synchronizeFolder(OCFile folder, boolean updateFolderProperties) {
if (mFailedResultsCounter > MAX_FAILED_RESULTS || isFinisher(mLastFailedResult))
return;
- // perform folder synchronization
- SynchronizeFolderOperation synchFolderOp = new SynchronizeFolderOperation( remotePath,
+ /*
+ OCFile folder,
+ long currentSyncTime,
+ boolean updateFolderProperties,
+ boolean syncFullAccount,
+ DataStorageManager dataStorageManager,
+ Account account,
+ Context context ) {
+
+ }
+ */
+ // folder synchronization
+ SynchronizeFolderOperation synchFolderOp = new SynchronizeFolderOperation( folder,
mCurrentSyncTime,
- parentId,
+ updateFolderProperties,
+ true,
getStorageManager(),
getAccount(),
getContext()
// synchronized folder -> notice to UI - ALWAYS, although !result.isSuccess
- sendStickyBroadcast(true, remotePath, null);
+ sendStickyBroadcast(true, folder.getRemotePath(), null);
+ // check the result of synchronizing the folder
if (result.isSuccess() || result.getCode() == ResultCode.SYNC_CONFLICT) {
if (result.getCode() == ResultCode.SYNC_CONFLICT) {
List<OCFile> children = synchFolderOp.getChildren();
fetchChildren(children); // beware of the 'hidden' recursion here!
- sendStickyBroadcast(true, remotePath, null);
+ // update folder size again after recursive synchronization
+ getStorageManager().calculateFolderSize(folder.getFileId());
+ sendStickyBroadcast(true, folder.getRemotePath(), null); // notify again
} else {
+ // in failures, the statistics for the global result are updated
if (result.getCode() == RemoteOperationResult.ResultCode.UNAUTHORIZED ||
- // (result.isTemporalRedirection() && result.isIdPRedirection() &&
( result.isIdPRedirection() &&
AccountAuthenticator.AUTH_TOKEN_TYPE_SAML_WEB_SSO_SESSION_COOKIE.equals(getClient().getAuthTokenType()))) {
mSyncResult.stats.numAuthExceptions++;
}
/**
- * Synchronize data of folders in the list of received files
+ * Triggers the synchronization of any folder contained in the list of received files.
*
- * @param files Files to recursively fetch
+ * @param files Files to recursively synchronize.
*/
private void fetchChildren(List<OCFile> files) {
int i;
for (i=0; i < files.size() && !mCancellation; i++) {
OCFile newFile = files.get(i);
if (newFile.isDirectory()) {
- fetchData(newFile.getRemotePath(), newFile.getFileId());
-
- // Update folder size on DB
- getStorageManager().calculateFolderSize(newFile.getFileId());
+ synchronizeFolder(newFile, false);
}
}
- if (mCancellation && i <files.size()) Log_OC.d(TAG, "Leaving synchronization before synchronizing " + files.get(i).getRemotePath() + " because cancelation request");
+ if (mCancellation && i <files.size()) Log_OC.d(TAG, "Leaving synchronization before synchronizing " + files.get(i).getRemotePath() + " due to cancelation request");
}
import android.os.IBinder;\r
\r
/**\r
- * Background service for syncing files to our local Database\r
+ * Background service for synchronizing remote files with their local state.\r
* \r
- * @author Bartek Przybylski\r
+ * Serves as a connector to an instance of {@link FileSyncAdapter}, as required by standard Android APIs. \r
* \r
+ * @author Bartek Przybylski\r
+ * @author David A. Velasco\r
*/\r
public class FileSyncService extends Service {\r
+ \r
public static final String SYNC_MESSAGE = "ACCOUNT_SYNC";\r
public static final String SYNC_FOLDER_REMOTE_PATH = "SYNC_FOLDER_REMOTE_PATH";\r
public static final String IN_PROGRESS = "SYNC_IN_PROGRESS";\r
public IBinder onBind(Intent intent) {\r
return new FileSyncAdapter(getApplicationContext(), true).getSyncAdapterBinder();\r
}\r
+ \r
}\r
import android.accounts.Account;
import android.app.AlertDialog;
-import android.app.ProgressDialog;
import android.app.Dialog;
+import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentResolver;
import com.owncloud.android.operations.OnRemoteOperationListener;
import com.owncloud.android.operations.RemoteOperation;
import com.owncloud.android.operations.RemoteOperationResult;
+import com.owncloud.android.operations.RemoteOperationResult.ResultCode;
import com.owncloud.android.operations.RemoveFileOperation;
import com.owncloud.android.operations.RenameFileOperation;
import com.owncloud.android.operations.SynchronizeFileOperation;
-import com.owncloud.android.operations.RemoteOperationResult.ResultCode;
+import com.owncloud.android.operations.SynchronizeFolderOperation;
import com.owncloud.android.syncadapter.FileSyncService;
import com.owncloud.android.ui.dialog.EditNameDialog;
+import com.owncloud.android.ui.dialog.EditNameDialog.EditNameDialogListener;
import com.owncloud.android.ui.dialog.LoadingDialog;
import com.owncloud.android.ui.dialog.SslValidatorDialog;
-import com.owncloud.android.ui.dialog.EditNameDialog.EditNameDialogListener;
import com.owncloud.android.ui.dialog.SslValidatorDialog.OnSslValidatorListener;
import com.owncloud.android.ui.fragment.FileDetailFragment;
import com.owncloud.android.ui.fragment.FileFragment;
private View mRightFragmentContainer;
private static final String KEY_WAITING_TO_PREVIEW = "WAITING_TO_PREVIEW";
+ private static final String KEY_SYNC_IN_PROGRESS = "SYNC_IN_PROGRESS";
public static final int DIALOG_SHORT_WAIT = 0;
private static final int DIALOG_CHOOSE_UPLOAD_SOURCE = 1;
private OCFile mWaitingToPreview;
private Handler mHandler;
+
+ private boolean mSyncInProgress = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
/// Load of saved instance state
if(savedInstanceState != null) {
mWaitingToPreview = (OCFile) savedInstanceState.getParcelable(FileDisplayActivity.KEY_WAITING_TO_PREVIEW);
-
+ mSyncInProgress = savedInstanceState.getBoolean(KEY_SYNC_IN_PROGRESS);
+
} else {
mWaitingToPreview = null;
- }
+ mSyncInProgress = false;
+ }
/// USER INTERFACE
// Action bar setup
mDirectories = new CustomArrayAdapter<String>(this, R.layout.sherlock_spinner_dropdown_item);
getSupportActionBar().setHomeButtonEnabled(true); // mandatory since Android ICS, according to the official documentation
- setSupportProgressBarIndeterminateVisibility(false); // always AFTER setContentView(...) ; to work around bug in its implementation
+ setSupportProgressBarIndeterminateVisibility(mSyncInProgress); // always AFTER setContentView(...) ; to work around bug in its implementation
Log_OC.d(TAG, "onCreate() end");
}
FileFragment second = getSecondFragment();
OCFile currentDir = getCurrentDir();
if((currentDir != null && currentDir.getParentId() != 0) ||
- (second != null && second.getFile() != null)) {
+ (second != null && second.getFile() != null)) {
onBackPressed();
+
}
break;
}
setFile(listOfFiles.getCurrentFile());
}
cleanSecondFragment();
+
}
@Override
Log_OC.e(TAG, "onSaveInstanceState() start");
super.onSaveInstanceState(outState);
outState.putParcelable(FileDisplayActivity.KEY_WAITING_TO_PREVIEW, mWaitingToPreview);
+ outState.putBoolean(FileDisplayActivity.KEY_SYNC_IN_PROGRESS, mSyncInProgress);
+
Log_OC.d(TAG, "onSaveInstanceState() end");
}
public void onReceive(Context context, Intent intent) {
boolean inProgress = intent.getBooleanExtra(FileSyncService.IN_PROGRESS, false);
String accountName = intent.getStringExtra(FileSyncService.ACCOUNT_NAME);
+ RemoteOperationResult synchResult = (RemoteOperationResult)intent.getSerializableExtra(FileSyncService.SYNC_RESULT);
Log_OC.d(TAG, "sync of account " + accountName + " is in_progress: " + inProgress);
-
+
if (getAccount() != null && accountName.equals(getAccount().name)) {
String synchFolderRemotePath = intent.getStringExtra(FileSyncService.SYNC_FOLDER_REMOTE_PATH);
- boolean fillBlankRoot = false;
- OCFile currentDir = getCurrentDir();
- if (currentDir == null) {
- currentDir = mStorageManager.getFileByPath(OCFile.PATH_SEPARATOR);
- fillBlankRoot = (currentDir != null);
- }
+ OCFile currentFile = mStorageManager.getFileById(getFile().getFileId());
+ OCFile currentDir = mStorageManager.getFileById(getCurrentDir().getFileId());
- if ((synchFolderRemotePath != null && currentDir != null && (currentDir.getRemotePath().equals(synchFolderRemotePath)))
- || fillBlankRoot ) {
- if (!fillBlankRoot)
- currentDir = getStorageManager().getFileByPath(synchFolderRemotePath);
- OCFileListFragment fileListFragment = getListOfFilesFragment();
- if (fileListFragment != null) {
- fileListFragment.listDirectory(currentDir);
+ if (currentDir == null) {
+ // current folder was removed from the server
+ Toast.makeText(FileDisplayActivity.this, getString(R.string.sync_current_folder_was_removed), Toast.LENGTH_LONG)
+ .show();
+ onBackPressed();
+
+ } else {
+ if (currentFile == null && !getFile().isDirectory()) {
+ // currently selected file was removed in the server, and now we know it
+ cleanSecondFragment();
+ currentFile = currentDir;
}
- if (getSecondFragment() == null)
- setFile(currentDir);
+
+ if (synchFolderRemotePath != null && currentDir.getRemotePath().equals(synchFolderRemotePath)) {
+ OCFileListFragment fileListFragment = getListOfFilesFragment();
+ if (fileListFragment != null) {
+ fileListFragment.listDirectory(currentDir);
+ }
+ }
+ setFile(currentFile);
}
setSupportProgressBarIndeterminateVisibility(inProgress);
removeStickyBroadcast(intent);
+ mSyncInProgress = inProgress;
}
-
- RemoteOperationResult synchResult = (RemoteOperationResult)intent.getSerializableExtra(FileSyncService.SYNC_RESULT);
+
if (synchResult != null) {
if (synchResult.getCode().equals(RemoteOperationResult.ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED)) {
mLastSslUntrustedServerResult = synchResult;
}
}
}
-
+
private class UploadFinishReceiver extends BroadcastReceiver {
/**
public void onBrowsedDownTo(OCFile directory) {
pushDirname(directory);
cleanSecondFragment();
+
+ // Sync Folder
+ startSyncFolderOperation(directory);
+
}
/**
}
+// private void updateDisplayHomeAtSync(){
+// ActionBar actionBar = getSupportActionBar();
+// OCFile currentDir = getCurrentDir();
+// if (currentDir.getParentId() != DataStorageManager.ROOT_PARENT_ID) {
+// actionBar.setHomeButtonEnabled(!mSyncInProgress);
+// actionBar.setDisplayHomeAsUpEnabled(!mSyncInProgress);
+// }
+// else {
+// actionBar.setHomeButtonEnabled(true);
+// actionBar.setDisplayHomeAsUpEnabled(false);
+// }
+// }
+//
/**
* {@inheritDoc}
*/
} else if (operation instanceof CreateFolderOperation) {
onCreateFolderOperationFinish((CreateFolderOperation)operation, result);
- }
+
+ }
}
refeshListOfFilesFragment();
} else {
- //dismissDialog(DIALOG_SHORT_WAIT);
dismissLoadingDialog();
try {
Toast msg = Toast.makeText(FileDisplayActivity.this, R.string.create_dir_fail_msg, Toast.LENGTH_LONG);
i.putExtra(ConflictsResolveActivity.EXTRA_ACCOUNT, getAccount());
startActivity(i);
- } else {
- Toast msg = Toast.makeText(this, R.string.sync_file_fail_msg, Toast.LENGTH_LONG);
- msg.show();
- }
+ }
} else {
if (operation.transferWasRequested()) {
}
return null;
}
+
+ public void startSyncFolderOperation(OCFile folder) {
+ long currentSyncTime = System.currentTimeMillis();
+
+ mSyncInProgress = true;
+
+ // perform folder synchronization
+ RemoteOperation synchFolderOp = new SynchronizeFolderOperation( folder,
+ currentSyncTime,
+ false,
+ false,
+ getStorageManager(),
+ getAccount(),
+ getApplicationContext()
+ );
+ synchFolderOp.execute(getAccount(), this, null, null, this);
+
+ setSupportProgressBarIndeterminateVisibility(true);
+ }
+
+// public void enableDisableViewGroup(ViewGroup viewGroup, boolean enabled) {
+// int childCount = viewGroup.getChildCount();
+// for (int i = 0; i < childCount; i++) {
+// View view = viewGroup.getChildAt(i);
+// view.setEnabled(enabled);
+// view.setClickable(!enabled);
+// if (view instanceof ViewGroup) {
+// enableDisableViewGroup((ViewGroup) view, enabled);
+// }
+// }
+// }
}
i.putExtra(ConflictsResolveActivity.EXTRA_ACCOUNT, mAccount);
startActivity(i);
- } else {
- Toast msg = Toast.makeText(getActivity(), R.string.sync_file_fail_msg, Toast.LENGTH_LONG);
- msg.show();
- }
+ }
if (file.isDown()) {
setButtonsForDown();
if(mFile != null){
DataStorageManager storageManager = mContainerActivity.getStorageManager();
- parentDir = storageManager.getFileById(mFile.getParentId());
- mFile = parentDir;
+ if (mFile.getParentId() == 0) {
+ parentDir = storageManager.getFileById(1);
+ }
+ else {
+ parentDir = storageManager.getFileById(mFile.getParentId());
+ }
+
+ mFile = parentDir;
}
- listDirectory(parentDir);
+
+ if (mFile != null) {
+ listDirectory(mFile);
+
+ mContainerActivity.startSyncFolderOperation(mFile);
+ }
+
}
@Override
mList.setSelectionFromTop(0, 0);
}
mFile = directory;
-
}
}
public void startMediaPreview(OCFile file, int i, boolean b);
public void startImagePreview(OCFile file);
+
+ public void startSyncFolderOperation(OCFile folder);
/**
* Getter for the current DataStorageManager in the container activity
import android.net.Uri;
public class WebdavEntry {
- private String mName, mPath, mUri, mContentType;
+ private String mName, mPath, mUri, mContentType, mEtag;
private long mContentLength, mCreateTimestamp, mModifiedTimestamp;
public WebdavEntry(MultiStatusResponse ms, String splitElement) {
DavPropertySet propSet = ms.getProperties(status);
@SuppressWarnings("rawtypes")
DavProperty prop = propSet.get(DavPropertyName.DISPLAYNAME);
- if (prop != null)
+ if (prop != null) {
mName = (String) prop.getName().toString();
+ mName = mName.substring(1, mName.length()-1);
+ }
else {
String[] tmp = mPath.split("/");
if (tmp.length > 0)
.parseResponseDate((String) prop.getValue());
mCreateTimestamp = (d != null) ? d.getTime() : 0;
}
+
+ prop = propSet.get(DavPropertyName.GETETAG);
+ if (prop != null) {
+ mEtag = (String) prop.getValue();
+ mEtag = mEtag.substring(1, mEtag.length()-1);
+ }
} else {
Log_OC.e("WebdavEntry",
public long modifiedTimestamp() {
return mModifiedTimestamp;
}
+
+ public String etag() {
+ return mEtag;
+ }
private void resetData() {
mName = mUri = mContentType = null;
projects / pub / Android / ownCloud.git / commitdiff