From: masensio Date: Thu, 28 Nov 2013 13:17:06 +0000 (+0100) Subject: Merge branch 'develop' into refactor_remote_operation_to_read_folder X-Git-Tag: oc-android-1.5.5~116^2~3 X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/commitdiff_plain/dc06df15c8c9b54b845f06cb4253a1b8af7d8f75?hp=d1bec2827119a417c50e5150ffed71c1961c72e9 Merge branch 'develop' into refactor_remote_operation_to_read_folder --- diff --git a/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/ReadFolderTest.java b/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/ReadFolderTest.java new file mode 100644 index 00000000..5bb4c35b --- /dev/null +++ b/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/ReadFolderTest.java @@ -0,0 +1,47 @@ +package com.owncloud.android.oc_framework_test_project.test; + + +import com.owncloud.android.oc_framework.operations.RemoteOperationResult; +import com.owncloud.android.oc_framework_test_project.TestActivity; + +import android.test.ActivityInstrumentationTestCase2; + +/** + * Class to test Read Folder Operation + * @author masensio + * + */ + +public class ReadFolderTest extends ActivityInstrumentationTestCase2 { + + + /* Folder data to read. This folder must exist on the account */ + private final String mRemoteFolderPath = "/folderToRead"; + + + private TestActivity mActivity; + + public ReadFolderTest() { + super(TestActivity.class); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + setActivityInitialTouchMode(false); + mActivity = getActivity(); + } + + /** + * Test Read Folder + */ + public void testReadFolder() { + + RemoteOperationResult result = mActivity.readFile(mRemoteFolderPath); + assertTrue(result.getFile() != null); + assertTrue(result.getData().size() > 0); + assertTrue(result.getData().size() == 3); + assertTrue(result.isSuccess()); + } + +} diff --git a/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/RenameFileTest.java b/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/RenameFileTest.java index fe30550b..e21c6ff8 100644 --- a/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/RenameFileTest.java +++ b/oc_framework-test-project/oc_framework-test-test/src/com/owncloud/android/oc_framework_test_project/test/RenameFileTest.java @@ -6,6 +6,12 @@ import com.owncloud.android.oc_framework_test_project.TestActivity; import android.test.ActivityInstrumentationTestCase2; +/** + * Class to test Rename File Operation + * @author masensio + * + */ + public class RenameFileTest extends ActivityInstrumentationTestCase2 { /* Folder data to rename. This folder must exist on the account */ diff --git a/oc_framework-test-project/src/com/owncloud/android/oc_framework_test_project/TestActivity.java b/oc_framework-test-project/src/com/owncloud/android/oc_framework_test_project/TestActivity.java index 12330a9a..db38ea5c 100644 --- a/oc_framework-test-project/src/com/owncloud/android/oc_framework_test_project/TestActivity.java +++ b/oc_framework-test-project/src/com/owncloud/android/oc_framework_test_project/TestActivity.java @@ -4,6 +4,7 @@ import com.owncloud.android.oc_framework.network.webdav.OwnCloudClientFactory; import com.owncloud.android.oc_framework.network.webdav.WebdavClient; import com.owncloud.android.oc_framework.operations.RemoteOperationResult; import com.owncloud.android.oc_framework.operations.remote.CreateRemoteFolderOperation; +import com.owncloud.android.oc_framework.operations.remote.ReadRemoteFolderOperation; import com.owncloud.android.oc_framework.operations.remote.RemoveRemoteFileOperation; import com.owncloud.android.oc_framework.operations.remote.RenameRemoteFileOperation; @@ -90,5 +91,18 @@ public class TestActivity extends Activity { return result; } + /** + * Access to the library method to Read a Folder (PROPFIND DEPTH 1) + * @param remotePath + * + * @return + */ + public RemoteOperationResult readFile(String remotePath) { + + ReadRemoteFolderOperation readOperation= new ReadRemoteFolderOperation(remotePath); + RemoteOperationResult result = readOperation.execute(mClient); + + return result; + } } diff --git a/oc_framework/.classpath b/oc_framework/.classpath index 51769745..72e286b9 100644 --- a/oc_framework/.classpath +++ b/oc_framework/.classpath @@ -5,5 +5,6 @@ + diff --git a/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteFile.java b/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteFile.java new file mode 100644 index 00000000..226f1f43 --- /dev/null +++ b/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteFile.java @@ -0,0 +1,153 @@ +package com.owncloud.android.oc_framework.operations; + +import java.io.Serializable; + +import android.os.Parcel; +import android.os.Parcelable; + +import com.owncloud.android.oc_framework.utils.FileUtils; + +/** + * Contains the data of a Remote File from a WebDavEntry + * + * @author masensio + */ + +public class RemoteFile implements Parcelable, Serializable{ + + /** Generated - should be refreshed every time the class changes!! */ + private static final long serialVersionUID = 7256606476031992757L; + + private String mRemotePath; + private String mMimeType; + private long mLength; + private long mCreationTimestamp; + private long mModifiedTimestamp; + private String mEtag; + + /** + * Getters and Setters + */ + + public String getRemotePath() { + return mRemotePath; + } + + public void setRemotePath(String remotePath) { + this.mRemotePath = remotePath; + } + + public String getMimeType() { + return mMimeType; + } + + public void setMimeType(String mimeType) { + this.mMimeType = mimeType; + } + + public long getLength() { + return mLength; + } + + public void setLength(long length) { + this.mLength = length; + } + + public long getCreationTimestamp() { + return mCreationTimestamp; + } + + public void setCreationTimestamp(long creationTimestamp) { + this.mCreationTimestamp = creationTimestamp; + } + + public long getModifiedTimestamp() { + return mModifiedTimestamp; + } + + public void setModifiedTimestamp(long modifiedTimestamp) { + this.mModifiedTimestamp = modifiedTimestamp; + } + + public String getEtag() { + return mEtag; + } + + public void setEtag(String etag) { + this.mEtag = etag; + } + + /** + * Create new {@link RemoteFile} with given path. + * + * The path received must be URL-decoded. Path separator must be OCFile.PATH_SEPARATOR, and it must be the first character in 'path'. + * + * @param path The remote path of the file. + */ + public RemoteFile(String path) { + resetData(); + if (path == null || path.length() <= 0 || !path.startsWith(FileUtils.PATH_SEPARATOR)) { + throw new IllegalArgumentException("Trying to create a OCFile with a non valid remote path: " + path); + } + mRemotePath = path; + } + + /** + * Used internally. Reset all file properties + */ + private void resetData() { + mRemotePath = null; + mMimeType = null; + mLength = 0; + mCreationTimestamp = 0; + mModifiedTimestamp = 0; + mEtag = null; + } + + /** + * Parcelable Methods + */ + public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { + @Override + public RemoteFile createFromParcel(Parcel source) { + return new RemoteFile(source); + } + + @Override + public RemoteFile[] newArray(int size) { + return new RemoteFile[size]; + } + }; + + + /** + * Reconstruct from parcel + * + * @param source The source parcel + */ + private RemoteFile(Parcel source) { + mRemotePath = source.readString(); + mMimeType = source.readString(); + mLength = source.readLong(); + mCreationTimestamp = source.readLong(); + mModifiedTimestamp = source.readLong(); + mEtag = source.readString(); + } + + @Override + public int describeContents() { + return this.hashCode(); + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(mRemotePath); + dest.writeString(mMimeType); + dest.writeLong(mLength); + dest.writeLong(mCreationTimestamp); + dest.writeLong(mModifiedTimestamp); + dest.writeString(mEtag); + } + + +} diff --git a/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteOperationResult.java b/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteOperationResult.java index f26988cc..3c650010 100644 --- a/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteOperationResult.java +++ b/oc_framework/src/com/owncloud/android/oc_framework/operations/RemoteOperationResult.java @@ -24,6 +24,7 @@ import java.net.MalformedURLException; import java.net.SocketException; import java.net.SocketTimeoutException; import java.net.UnknownHostException; +import java.util.ArrayList; import javax.net.ssl.SSLException; @@ -51,10 +52,8 @@ import android.util.Log; */ public class RemoteOperationResult implements Serializable { - /** Generated - should be refreshed every time the class changes!! */ - private static final long serialVersionUID = -4415103901492836870L; - - + /** Generated - should be refreshed every time the class changes!! */ + private static final long serialVersionUID = -2469951225222759283L; private static final String TAG = "RemoteOperationResult"; @@ -99,9 +98,14 @@ public class RemoteOperationResult implements Serializable { private ResultCode mCode = ResultCode.UNKNOWN_ERROR; private String mRedirectedLocation; + private RemoteFile mFile; + private ArrayList mFiles; + public RemoteOperationResult(ResultCode code) { mCode = code; mSuccess = (code == ResultCode.OK || code == ResultCode.OK_SSL || code == ResultCode.OK_NO_SSL); + mFile= null; + mFiles = null; } private RemoteOperationResult(boolean success, int httpCode) { @@ -196,6 +200,21 @@ public class RemoteOperationResult implements Serializable { } + + public void setFile(RemoteFile file){ + mFile = file; + } + public RemoteFile getFile(){ + return mFile; + } + public void setData(ArrayList files){ + mFiles = files; + } + + public ArrayList getData(){ + return mFiles; + } + public boolean isSuccess() { return mSuccess; } diff --git a/oc_framework/src/com/owncloud/android/oc_framework/operations/remote/ReadRemoteFolderOperation.java b/oc_framework/src/com/owncloud/android/oc_framework/operations/remote/ReadRemoteFolderOperation.java new file mode 100644 index 00000000..3a9eb193 --- /dev/null +++ b/oc_framework/src/com/owncloud/android/oc_framework/operations/remote/ReadRemoteFolderOperation.java @@ -0,0 +1,148 @@ +package com.owncloud.android.oc_framework.operations.remote; + +import java.util.ArrayList; + +import org.apache.http.HttpStatus; +import org.apache.jackrabbit.webdav.DavConstants; +import org.apache.jackrabbit.webdav.MultiStatus; +import org.apache.jackrabbit.webdav.client.methods.PropFindMethod; + +import android.util.Log; + +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.RemoteFile; +import com.owncloud.android.oc_framework.operations.RemoteOperation; +import com.owncloud.android.oc_framework.operations.RemoteOperationResult; + +/** + * Remote operation performing the read of remote file or folder in the ownCloud server. + * + * @author David A. Velasco + * @author masensio + */ + +public class ReadRemoteFolderOperation extends RemoteOperation { + + private static final String TAG = ReadRemoteFolderOperation.class.getSimpleName(); + + private String mRemotePath; + private RemoteFile mFolder; + private ArrayList mFiles; + + /** + * Constructor + * + * @param remotePath Remote path of the file. + */ + public ReadRemoteFolderOperation(String remotePath) { + mRemotePath = remotePath; + } + + /** + * Performs the read operation. + * + * @param client Client object to communicate with the remote ownCloud server. + */ + @Override + protected RemoteOperationResult run(WebdavClient client) { + RemoteOperationResult result = null; + PropFindMethod query = null; + + try { + // remote request + query = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(mRemotePath), + DavConstants.PROPFIND_ALL_PROP, + DavConstants.DEPTH_1); + int status = client.executeMethod(query); + + // check and process response + if (isMultiStatus(status)) { + // get data from remote folder + MultiStatus dataInServer = query.getResponseBodyAsMultiStatus(); + readData(dataInServer, client); + + // Result of the operation + result = new RemoteOperationResult(true, status, query.getResponseHeaders()); + // Add data to the result + if (result.isSuccess()) { + result.setFile(mFolder); + result.setData(mFiles); + } + } else { + // synchronization failed + client.exhaustResponse(query.getResponseBodyAsStream()); + result = new RemoteOperationResult(false, status, query.getResponseHeaders()); + } + + } catch (Exception e) { + result = new RemoteOperationResult(e); + + + } finally { + if (query != null) + query.releaseConnection(); // let the connection available for other methods + if (result.isSuccess()) { + Log.i(TAG, "Synchronized " + mRemotePath + ": " + result.getLogMessage()); + } else { + if (result.isException()) { + Log.e(TAG, "Synchronized " + mRemotePath + ": " + result.getLogMessage(), result.getException()); + } else { + Log.e(TAG, "Synchronized " + mRemotePath + ": " + result.getLogMessage()); + } + } + + } + return result; + } + + public boolean isMultiStatus(int status) { + return (status == HttpStatus.SC_MULTI_STATUS); + } + + /** + * Read the data retrieved from the server about the contents of the target folder + * + * + * @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 + */ + private void readData(MultiStatus dataInServer, WebdavClient client) { + // parse data from remote folder + WebdavEntry we = new WebdavEntry(dataInServer.getResponses()[0], client.getBaseUri().getPath()); + mFolder = fillOCFile(we); + + + // loop to update every child + RemoteFile remoteFile = null; + mFiles = new ArrayList(); + 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); + + mFiles.add(remoteFile); + } + + } + + /** + * Creates and populates a new {@link RemoteFile} object with the data read from the server. + * + * @param we WebDAV entry read from the server for a WebDAV resource (remote file or folder). + * @return New OCFile instance representing the remote resource described by we. + */ + private RemoteFile fillOCFile(WebdavEntry we) { + RemoteFile file = new RemoteFile(we.decodedPath()); + file.setCreationTimestamp(we.createTimestamp()); + file.setLength(we.contentLength()); + file.setMimeType(we.contentType()); + file.setModifiedTimestamp(we.modifiedTimestamp()); + file.setEtag(we.etag()); + return file; + } +} diff --git a/src/com/owncloud/android/operations/SynchronizeFolderOperation.java b/src/com/owncloud/android/operations/SynchronizeFolderOperation.java index 780fd42c..2fc9d28b 100644 --- a/src/com/owncloud/android/operations/SynchronizeFolderOperation.java +++ b/src/com/owncloud/android/operations/SynchronizeFolderOperation.java @@ -23,6 +23,7 @@ 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; import java.util.Map; @@ -30,7 +31,6 @@ import java.util.Vector; import org.apache.http.HttpStatus; import org.apache.jackrabbit.webdav.DavConstants; -import org.apache.jackrabbit.webdav.MultiStatus; import org.apache.jackrabbit.webdav.client.methods.PropFindMethod; import android.accounts.Account; @@ -45,6 +45,8 @@ 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; @@ -241,59 +243,27 @@ public class SynchronizeFolderOperation extends RemoteOperation { private RemoteOperationResult fetchAndSyncRemoteFolder(WebdavClient client) { - RemoteOperationResult result = null; - String remotePath = null; - PropFindMethod query = null; - try { - remotePath = mLocalFolder.getRemotePath(); - Log_OC.d(TAG, "Synchronizing " + mAccount.name + remotePath); - - // remote request - query = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(remotePath), - DavConstants.PROPFIND_ALL_PROP, - DavConstants.DEPTH_1); - int status = client.executeMethod(query); - - // check and process response - if (isMultiStatus(status)) { - synchronizeData(query.getResponseBodyAsMultiStatus(), client); - 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()); - } - - } else { - // synchronization failed - client.exhaustResponse(query.getResponseBodyAsStream()); - if (status == HttpStatus.SC_NOT_FOUND) { - removeLocalFolder(); - } - result = new RemoteOperationResult(false, status, query.getResponseHeaders()); - } - - } catch (Exception e) { - result = new RemoteOperationResult(e); - - - } finally { - if (query != null) - query.releaseConnection(); // let the connection available for other methods - if (result.isSuccess()) { - Log_OC.i(TAG, "Synchronized " + mAccount.name + remotePath + ": " + result.getLogMessage()); - } else { - if (result.isException()) { - Log_OC.e(TAG, "Synchronized " + mAccount.name + remotePath + ": " + result.getLogMessage(), result.getException()); - } else { - Log_OC.e(TAG, "Synchronized " + mAccount.name + remotePath + ": " + result.getLogMessage()); - } + 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()) { + RemoteFile folder = result.getFile(); + ArrayList files = result.getData(); + synchronizeData(folder, files, 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); @@ -307,26 +277,27 @@ public class SynchronizeFolderOperation extends RemoteOperation { * 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 folder Remote Folder to synchronize + * + * @param files Remote 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(MultiStatus dataInServer, WebdavClient client) { + private void synchronizeData(RemoteFile folder, ArrayList files, WebdavClient client) { // get 'fresh data' from the database mLocalFolder = mStorageManager.getFileByPath(mLocalFolder.getRemotePath()); // parse data from remote folder - WebdavEntry we = new WebdavEntry(dataInServer.getResponses()[0], client.getBaseUri().getPath()); - OCFile remoteFolder = fillOCFile(we); + OCFile remoteFolder = fillOCFile(folder); 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(dataInServer.getResponses().length - 1); + List updatedFiles = new Vector(files.size()); List filesToSyncContents = new Vector(); // get current data about local contents of the folder to synchronize @@ -338,10 +309,9 @@ public class SynchronizeFolderOperation extends RemoteOperation { // loop to update every child OCFile remoteFile = null, localFile = null; - for (int i = 1; i < dataInServer.getResponses().length; ++i) { + for (RemoteFile file: files) { /// new OCFile instance with the data from the server - we = new WebdavEntry(dataInServer.getResponses()[i], client.getBaseUri().getPath()); - remoteFile = fillOCFile(we); + remoteFile = fillOCFile(file); remoteFile.setParentId(mLocalFolder.getFileId()); /// retrieve local data for the read file @@ -432,7 +402,7 @@ public class SynchronizeFolderOperation extends RemoteOperation { return (status == HttpStatus.SC_MULTI_STATUS); } - + /** * Creates and populates a new {@link OCFile} object with the data read from the server. * @@ -448,6 +418,22 @@ public class SynchronizeFolderOperation extends RemoteOperation { 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; + } /**