Added some neccesities for the copy operation

src/com/owncloud/android/lib/common/operations/RemoteOperationResult.java

@@ -33,8 +33,12 @@ import java.net.SocketException;
 import java.net.SocketTimeoutException;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
+import android.accounts.Account;
+import android.accounts.AccountsException;
 
-import javax.net.ssl.SSLException;
+import com.owncloud.android.lib.common.accounts.AccountUtils.AccountNotFoundException;
+import com.owncloud.android.lib.common.network.CertificateCombinedException;
+import com.owncloud.android.lib.common.utils.Log_OC;
 
 import org.apache.commons.httpclient.ConnectTimeoutException;
 import org.apache.commons.httpclient.Header;
@@ -43,24 +47,27 @@ import org.apache.commons.httpclient.HttpStatus;
 import org.apache.jackrabbit.webdav.DavException;
 import org.json.JSONException;
 
-import android.accounts.Account;
+import java.io.IOException;
-import android.accounts.AccountsException;
+import java.io.Serializable;
+import java.net.MalformedURLException;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
 
-import com.owncloud.android.lib.common.accounts.AccountUtils.AccountNotFoundException;
+import javax.net.ssl.SSLException;
-import com.owncloud.android.lib.common.network.CertificateCombinedException;
-import com.owncloud.android.lib.common.utils.Log_OC;
 
 
 /**
  * The result of a remote operation required to an ownCloud server.
- * 
+ * <p/>
  * Provides a common classification of remote operation results for all the
  * application.
- * 
+ *
  * @author David A. Velasco
  */
 public class RemoteOperationResult implements Serializable {
-	
+
 	/** Generated - should be refreshed every time the class changes!! */;
     private static final long serialVersionUID = -1909603208238358633L;
 
@@ -71,32 +78,32 @@ public class RemoteOperationResult implements Serializable {
         OK_SSL,
         OK_NO_SSL,
         UNHANDLED_HTTP_CODE,
-        UNAUTHORIZED,        
+        UNAUTHORIZED,
-        FILE_NOT_FOUND, 
+        FILE_NOT_FOUND,
-        INSTANCE_NOT_CONFIGURED, 
+        INSTANCE_NOT_CONFIGURED,
-        UNKNOWN_ERROR, 
+        UNKNOWN_ERROR,
-        WRONG_CONNECTION,  
+        WRONG_CONNECTION,
-        TIMEOUT, 
+        TIMEOUT,
-        INCORRECT_ADDRESS, 
+        INCORRECT_ADDRESS,
-        HOST_NOT_AVAILABLE, 
+        HOST_NOT_AVAILABLE,
-        NO_NETWORK_CONNECTION, 
+        NO_NETWORK_CONNECTION,
         SSL_ERROR,
         SSL_RECOVERABLE_PEER_UNVERIFIED,
         BAD_OC_VERSION,
-        CANCELLED, 
+        CANCELLED,
-        INVALID_LOCAL_FILE_NAME, 
+        INVALID_LOCAL_FILE_NAME,
         INVALID_OVERWRITE,
-        CONFLICT, 
+        CONFLICT,
         OAUTH2_ERROR,
         SYNC_CONFLICT,
-        LOCAL_STORAGE_FULL, 
+        LOCAL_STORAGE_FULL,
-        LOCAL_STORAGE_NOT_MOVED, 
+        LOCAL_STORAGE_NOT_MOVED,
-        LOCAL_STORAGE_NOT_COPIED, 
+        LOCAL_STORAGE_NOT_COPIED,
         OAUTH2_ERROR_ACCESS_DENIED,
-        QUOTA_EXCEEDED, 
+        QUOTA_EXCEEDED,
-        ACCOUNT_NOT_FOUND, 
+        ACCOUNT_NOT_FOUND,
-        ACCOUNT_EXCEPTION, 
+        ACCOUNT_EXCEPTION,
-        ACCOUNT_NOT_NEW, 
+        ACCOUNT_NOT_NEW,
         ACCOUNT_NOT_THE_SAME,
         INVALID_CHARACTER_IN_NAME,
         SHARE_NOT_FOUND,
@@ -106,6 +113,7 @@ public class RemoteOperationResult implements Serializable {
 		OK_REDIRECT_TO_NON_SECURE_CONNECTION, 
 		INVALID_MOVE_INTO_DESCENDANT, 
 		PARTIAL_MOVE_DONE,
+        PARTIAL_COPY_DONE,
         INVALID_CHARACTER_DETECT_IN_SERVER
     }
 
@@ -161,20 +169,20 @@ public class RemoteOperationResult implements Serializable {
             }
         }
     }
-    
+
     public RemoteOperationResult(boolean success, int httpCode, Header[] headers) {
         this(success, httpCode);
         if (headers != null) {
             Header current;
-            for (int i=0; i<headers.length; i++) {
+            for (int i = 0; i < headers.length; i++) {
                 current = headers[i];
                 if ("location".equals(current.getName().toLowerCase())) {
                     mRedirectedLocation = current.getValue();
                     continue;
                 }
                 if ("www-authenticate".equals(current.getName().toLowerCase())) {
-                	mAuthenticate = current.getValue();
+                    mAuthenticate = current.getValue();
-                	continue;
+                    continue;
                 }
             }
         }
@@ -234,10 +242,10 @@ public class RemoteOperationResult implements Serializable {
 
         } else if (e instanceof AccountNotFoundException) {
             mCode = ResultCode.ACCOUNT_NOT_FOUND;
-            
+
         } else if (e instanceof AccountsException) {
             mCode = ResultCode.ACCOUNT_EXCEPTION;
-            
+
         } else if (e instanceof SSLException || e instanceof RuntimeException) {
             CertificateCombinedException se = getCertificateCombinedException(e);
             if (se != null) {
@@ -259,14 +267,14 @@ public class RemoteOperationResult implements Serializable {
     }
 
 
-    public void setData(ArrayList<Object> files){
+    public void setData(ArrayList<Object> files) {
-    	mData = files;
+        mData = files;
     }
-    
+
-	public ArrayList<Object> getData(){
+    public ArrayList<Object> getData() {
-		return mData;
+        return mData;
-	}
+    }
-    
+
     public boolean isSuccess() {
         return mSuccess;
     }
@@ -291,9 +299,9 @@ public class RemoteOperationResult implements Serializable {
         return mCode == ResultCode.SSL_RECOVERABLE_PEER_UNVERIFIED;
     }
 
-	public boolean isRedirectToNonSecureConnection() {
+    public boolean isRedirectToNonSecureConnection() {
-		return mCode == ResultCode.OK_REDIRECT_TO_NON_SECURE_CONNECTION;
+        return mCode == ResultCode.OK_REDIRECT_TO_NON_SECURE_CONNECTION;
-	}
+    }
 
     private CertificateCombinedException getCertificateCombinedException(Exception e) {
         CertificateCombinedException result = null;
@@ -360,10 +368,10 @@ public class RemoteOperationResult implements Serializable {
                 
             } else if (mException instanceof AccountsException) {
                 return "Exception while using account";
-                
+
             } else if (mException instanceof JSONException) {
-            	return "JSON exception";
+                return "JSON exception";
-            	
+
             } else {
                 return "Unexpected exception";
             }
@@ -415,25 +423,24 @@ public class RemoteOperationResult implements Serializable {
     public String getRedirectedLocation() {
         return mRedirectedLocation;
     }
-    
+
     public boolean isIdPRedirection() {
         return (mRedirectedLocation != null &&
-                (mRedirectedLocation.toUpperCase().contains("SAML") || 
+                (mRedirectedLocation.toUpperCase().contains("SAML") ||
-                mRedirectedLocation.toLowerCase().contains("wayf")));
+                        mRedirectedLocation.toLowerCase().contains("wayf")));
+    }
+
+    /**
+     * Checks if is a non https connection
+     *
+     * @return boolean true/false
+     */
+    public boolean isNonSecureRedirection() {
+        return (mRedirectedLocation != null && !(mRedirectedLocation.toLowerCase().startsWith("https://")));
     }
-    
-	/**
-	 * Checks if is a non https connection
-	 * 
-	 * @return boolean true/false
-	 */
-	public boolean isNonSecureRedirection() {
-		return (mRedirectedLocation != null &&
-                !(mRedirectedLocation.toLowerCase().startsWith("https://")));
-	}
 
     public String getAuthenticateHeader() {
-    	return mAuthenticate;
+        return mAuthenticate;
     }
 
     public String getLastPermanentLocation() {

src/com/owncloud/android/lib/resources/files/CopyRemoteFileOperation.java

@@ -0,0 +1,215 @@
+/* ownCloud Android Library is available under MIT license
+ *   Copyright (C) 2014 ownCloud Inc.
+ *   
+ *   Permission is hereby granted, free of charge, to any person obtaining a copy
+ *   of this software and associated documentation files (the "Software"), to deal
+ *   in the Software without restriction, including without limitation the rights
+ *   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *   copies of the Software, and to permit persons to whom the Software is
+ *   furnished to do so, subject to the following conditions:
+ *   
+ *   The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ *   
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+ *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+ *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
+ *   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ *   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+ *   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *   THE SOFTWARE.
+ *
+ */
+
+package com.owncloud.android.lib.resources.files;
+
+import android.util.Log;
+
+import com.owncloud.android.lib.common.OwnCloudClient;
+import com.owncloud.android.lib.common.network.WebdavUtils;
+import com.owncloud.android.lib.common.operations.RemoteOperation;
+import com.owncloud.android.lib.common.operations.RemoteOperationResult;
+import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode;
+import com.owncloud.android.lib.resources.status.OwnCloudVersion;
+
+import org.apache.commons.httpclient.HttpStatus;
+import org.apache.jackrabbit.webdav.DavException;
+import org.apache.jackrabbit.webdav.MultiStatusResponse;
+import org.apache.jackrabbit.webdav.Status;
+import org.apache.jackrabbit.webdav.client.methods.CopyMethod;
+
+import java.io.IOException;
+
+
+/**
+ * Remote operation moving a remote file or folder in the ownCloud server to a different folder
+ * in the same account.
+ * <p/>
+ * Allows renaming the moving file/folder at the same time.
+ *
+ * @author David A. Velasco
+ */
+public class CopyRemoteFileOperation extends RemoteOperation {
+
+    private static final String TAG = CopyRemoteFileOperation.class.getSimpleName();
+
+    private static final int COPY_READ_TIMEOUT = 600000;
+    private static final int COPY_CONNECTION_TIMEOUT = 5000;
+
+    private String mSrcRemotePath;
+    private String mTargetRemotePath;
+
+    private boolean mOverwrite;
+
+
+    /**
+     * Constructor.
+     * <p/>
+     * TODO Paths should finish in "/" in the case of folders. ?
+     *
+     * @param srcRemotePath    Remote path of the file/folder to move.
+     * @param targetRemotePath Remove path desired for the file/folder after moving it.
+     */
+    public CopyRemoteFileOperation(
+            String srcRemotePath, String targetRemotePath, boolean overwrite
+    ) {
+
+        mSrcRemotePath = srcRemotePath;
+        mTargetRemotePath = targetRemotePath;
+        mOverwrite = overwrite;
+    }
+
+
+    /**
+     * Performs the rename operation.
+     *
+     * @param client Client object to communicate with the remote ownCloud server.
+     */
+    @Override
+    protected RemoteOperationResult run(OwnCloudClient client) {
+
+        OwnCloudVersion version = client.getOwnCloudVersion();
+        boolean versionWithForbiddenChars =
+                (version != null && version.isVersionWithForbiddenCharacters());
+
+        /// check parameters
+        if (!FileUtils.isValidPath(mTargetRemotePath, versionWithForbiddenChars)) {
+            return new RemoteOperationResult(ResultCode.INVALID_CHARACTER_IN_NAME);
+        }
+
+        if (mTargetRemotePath.equals(mSrcRemotePath)) {
+            // nothing to do!
+            return new RemoteOperationResult(ResultCode.OK);
+        }
+
+        if (mTargetRemotePath.startsWith(mSrcRemotePath)) {
+            return new RemoteOperationResult(ResultCode.INVALID_MOVE_INTO_DESCENDANT);
+        }
+
+
+        /// perform remote operation
+        CopyMethod copyMethod = null;
+        RemoteOperationResult result = null;
+        try {
+            copyMethod = new CopyMethod(
+                    client.getWebdavUri() + WebdavUtils.encodePath(mSrcRemotePath),
+                    client.getWebdavUri() + WebdavUtils.encodePath(mTargetRemotePath),
+                    mOverwrite
+            );
+            int status = client.executeMethod(copyMethod, COPY_READ_TIMEOUT, COPY_CONNECTION_TIMEOUT);
+
+            /// process response
+            if (status == HttpStatus.SC_MULTI_STATUS) {
+                result = processPartialError(copyMethod);
+
+            } else if (status == HttpStatus.SC_PRECONDITION_FAILED && !mOverwrite) {
+
+                result = new RemoteOperationResult(ResultCode.INVALID_OVERWRITE);
+                client.exhaustResponse(copyMethod.getResponseBodyAsStream());
+
+
+                /// for other errors that could be explicitly handled, check first:
+                /// http://www.webdav.org/specs/rfc4918.html#rfc.section.9.9.4
+
+            } else {
+                result = new RemoteOperationResult(
+                        isSuccess(status),    // copy.succeeded()? trustful?
+                        status,
+                        copyMethod.getResponseHeaders()
+                );
+                client.exhaustResponse(copyMethod.getResponseBodyAsStream());
+            }
+
+            Log.i(TAG, "Copy " + mSrcRemotePath + " to " + mTargetRemotePath + ": " +
+                    result.getLogMessage());
+
+        } catch (Exception e) {
+            result = new RemoteOperationResult(e);
+            Log.e(TAG, "Copy " + mSrcRemotePath + " to " + mTargetRemotePath + ": " +
+                    result.getLogMessage(), e);
+
+        } finally {
+            if (copyMethod != null)
+                copyMethod.releaseConnection();
+        }
+
+        return result;
+    }
+
+
+    /**
+     * Analyzes a multistatus response from the OC server to generate an appropriate result.
+     * <p/>
+     * In WebDAV, a COPY request on collections (folders) can be PARTIALLY successful: some
+     * children are copied, some other aren't.
+     * <p/>
+     * According to the WebDAV specification, a multistatus response SHOULD NOT include partial
+     * successes (201, 204) nor for descendants of already failed children (424) in the response
+     * entity. But SHOULD NOT != MUST NOT, so take carefully.
+     *
+     * @param copyMethod Copy operation just finished with a multistatus response
+     * @return A result for the {@link com.owncloud.android.lib.resources.files.CopyRemoteFileOperation} caller
+     * @throws java.io.IOException                       If the response body could not be parsed
+     * @throws org.apache.jackrabbit.webdav.DavException If the status code is other than MultiStatus or if obtaining
+     *                                                   the response XML document fails
+     */
+    private RemoteOperationResult processPartialError(CopyMethod copyMethod)
+            throws IOException, DavException {
+        // Adding a list of failed descendants to the result could be interesting; or maybe not.
+        // For the moment, let's take the easy way.
+
+        /// check that some error really occurred
+        MultiStatusResponse[] responses = copyMethod.getResponseBodyAsMultiStatus().getResponses();
+        Status[] status;
+        boolean failFound = false;
+        for (int i = 0; i < responses.length && !failFound; i++) {
+            status = responses[i].getStatus();
+            failFound = (
+                    status != null &&
+                            status.length > 0 &&
+                            status[0].getStatusCode() > 299
+            );
+        }
+
+        RemoteOperationResult result;
+        if (failFound) {
+            result = new RemoteOperationResult(ResultCode.PARTIAL_COPY_DONE);
+        } else {
+            result = new RemoteOperationResult(
+                    true,
+                    HttpStatus.SC_MULTI_STATUS,
+                    copyMethod.getResponseHeaders()
+            );
+        }
+
+        return result;
+
+    }
+
+
+    protected boolean isSuccess(int status) {
+        return status == HttpStatus.SC_CREATED || status == HttpStatus.SC_NO_CONTENT;
+    }
+
+}