Bug fixed: download followed by refresh always resulted in upload, although the file...

[pub/Android/ownCloud.git] / 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 d189994..9923c17 100644 (file)
--- a/src/com/owncloud/android/operations/SynchronizeFileOperation.java
+++ b/src/com/owncloud/android/operations/SynchronizeFileOperation.java
@@ -1,3 +1,21 @@
+/* ownCloud Android client application
+ *   Copyright (C) 2012 Bartek Przybylski
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+

 package com.owncloud.android.operations;
 
 import org.apache.http.HttpStatus;
 package com.owncloud.android.operations;
 
 import org.apache.http.HttpStatus;


@@ -6,10 +24,14 @@ import org.apache.jackrabbit.webdav.client.methods.PropFindMethod;
 
 import android.accounts.Account;
 import android.content.Context;
 
 import android.accounts.Account;
 import android.content.Context;

+import android.content.Intent;

 import android.util.Log;
 
 import com.owncloud.android.datamodel.DataStorageManager;
 import com.owncloud.android.datamodel.OCFile;
 import android.util.Log;
 
 import com.owncloud.android.datamodel.DataStorageManager;
 import com.owncloud.android.datamodel.OCFile;

+import com.owncloud.android.files.services.FileDownloader;
+import com.owncloud.android.files.services.FileUploader;
+import com.owncloud.android.operations.RemoteOperationResult.ResultCode;

 
 import eu.alefzero.webdav.WebdavClient;
 import eu.alefzero.webdav.WebdavEntry;
 
 import eu.alefzero.webdav.WebdavClient;
 import eu.alefzero.webdav.WebdavEntry;


@@ -18,53 +40,115 @@ import eu.alefzero.webdav.WebdavUtils;
 public class SynchronizeFileOperation extends RemoteOperation {
 
     private String TAG = SynchronizeFileOperation.class.getSimpleName();
 public class SynchronizeFileOperation extends RemoteOperation {
 
     private String TAG = SynchronizeFileOperation.class.getSimpleName();

-    
-    private String mRemotePath;
-    
+    //private String mRemotePath;
+    private OCFile mLocalFile;

     private DataStorageManager mStorageManager;
     private DataStorageManager mStorageManager;

-    

     private Account mAccount;
     private Account mAccount;

+    private boolean mSyncFileContents;
+    private boolean mLocalChangeAlreadyKnown;
+    private Context mContext;
+    
+    private boolean mTransferWasRequested = false;

     
     public SynchronizeFileOperation(
     
     public SynchronizeFileOperation(

-            String remotePath, 
+            OCFile localFile, 

             DataStorageManager dataStorageManager, 
             Account account, 
             DataStorageManager dataStorageManager, 
             Account account, 

-            Context context ) {
-        mRemotePath = remotePath;
+            boolean syncFileContents,
+            boolean localChangeAlreadyKnown,
+            Context context) {
+        
+        //mRemotePath = remotePath;
+        mLocalFile = localFile;

         mStorageManager = dataStorageManager;
         mAccount = account;
         mStorageManager = dataStorageManager;
         mAccount = account;

+        mSyncFileContents = syncFileContents;
+        mLocalChangeAlreadyKnown = localChangeAlreadyKnown;
+        mContext = context;

     }
 
     }
 

+    

     @Override
     protected RemoteOperationResult run(WebdavClient client) {
     @Override
     protected RemoteOperationResult run(WebdavClient client) {

+        

         PropFindMethod propfind = null;
         RemoteOperationResult result = null;
         PropFindMethod propfind = null;
         RemoteOperationResult result = null;

+        mTransferWasRequested = false;

         try {
         try {

-          propfind = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(mRemotePath));
-          int status = client.executeMethod(propfind);
-          boolean isMultiStatus = status == HttpStatus.SC_MULTI_STATUS;
-          Boolean isConflict = Boolean.FALSE;
-          if (isMultiStatus) {
-              MultiStatus resp = propfind.getResponseBodyAsMultiStatus();
-              WebdavEntry we = new WebdavEntry(resp.getResponses()[0],
+            if (!mLocalFile.isDown()) {
+                /// easy decision
+                requestForDownload(mLocalFile);
+                result = new RemoteOperationResult(ResultCode.OK);
+                
+            } else {
+                /// local copy in the device -> need to think a bit more before do anything
+                
+                propfind = new PropFindMethod(client.getBaseUri() + WebdavUtils.encodePath(mLocalFile.getRemotePath()));
+                int status = client.executeMethod(propfind);
+                boolean isMultiStatus = status == HttpStatus.SC_MULTI_STATUS;
+                if (isMultiStatus) {
+                    MultiStatus resp = propfind.getResponseBodyAsMultiStatus();
+                    WebdavEntry we = new WebdavEntry(resp.getResponses()[0],

                                                client.getBaseUri().getPath());
                                                client.getBaseUri().getPath());

-              OCFile file = fillOCFile(we);
-              OCFile oldFile = mStorageManager.getFileByPath(file.getRemotePath());
-              if (oldFile.getFileLength() != file.getFileLength() ||
-                  oldFile.getModificationTimestamp() != file.getModificationTimestamp()) {
-                  isConflict = Boolean.TRUE;
-              }
+                    OCFile serverFile = fillOCFile(we);
+              
+                    /// check changes in server and local file
+                    boolean serverChanged = false;
+                    if (serverFile.getEtag() != null) {
+                        serverChanged = (!serverFile.getEtag().equals(mLocalFile.getEtag()));   // TODO could this be dangerous when the user upgrades the server from non-tagged to tagged?
+                    } else {
+                        // server without etags
+                        serverChanged = (serverFile.getModificationTimestamp() > mLocalFile.getModificationTimestamp());
+                    }
+                    boolean localChanged = (mLocalChangeAlreadyKnown || mLocalFile.getLocalModificationTimestamp() > mLocalFile.getLastSyncDateForData());
+                        // TODO this will be always true after the app is upgraded to database version 3; will result in unnecessary uploads

               
               

-          } else {
-              client.exhaustResponse(propfind.getResponseBodyAsStream());
-          }
+                    /// decide action to perform depending upon changes
+                    if (localChanged && serverChanged) {
+                        // conflict
+                        result = new RemoteOperationResult(ResultCode.SYNC_CONFLICT);
+                  
+                    } else if (localChanged) {
+                        if (mSyncFileContents) {
+                            requestForUpload(mLocalFile);
+                            // the local update of file properties will be done by the FileUploader service when the upload finishes
+                        } else {
+                            // NOTHING TO DO HERE: updating the properties of the file in the server without uploading the contents would be stupid; 
+                            // So, an instance of SynchronizeFileOperation created with syncFileContents == false is completely useless when we suspect
+                            // that an upload is necessary (for instance, in FileObserverService).
+                        }
+                        result = new RemoteOperationResult(ResultCode.OK);
+                  
+                    } else if (serverChanged) {
+                        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
+                        } else {
+                            // TODO CHECK: is this really useful in some point in the code?
+                            serverFile.setKeepInSync(mLocalFile.keepInSync());
+                            serverFile.setParentId(mLocalFile.getParentId());
+                            mStorageManager.saveFile(serverFile);
+                            
+                        }
+                        result = new RemoteOperationResult(ResultCode.OK);
+              
+                    } else {
+                        // nothing changed, nothing to do
+                        result = new RemoteOperationResult(ResultCode.OK);
+                    }
+              
+                } else {
+                    client.exhaustResponse(propfind.getResponseBodyAsStream());
+                    result = new RemoteOperationResult(false, status);
+                }
+          
+            }
+            
+            Log.i(TAG, "Synchronizing " + mAccount.name + ", file " + mLocalFile.getRemotePath() + ": " + result.getLogMessage());

           
           

-          result = new RemoteOperationResult(isMultiStatus, status);
-          result.setExtraData(isConflict);
-          Log.i(TAG, "Synchronizing " + mAccount.name + ", file " + mRemotePath + ": " + result.getLogMessage());

         } catch (Exception e) {
             result = new RemoteOperationResult(e);
         } catch (Exception e) {
             result = new RemoteOperationResult(e);

-            Log.e(TAG, "Synchronizing " + mAccount.name + ", file " + mRemotePath + ": " + result.getLogMessage(), result.getException());
+            Log.e(TAG, "Synchronizing " + mAccount.name + ", file " + mLocalFile.getRemotePath() + ": " + result.getLogMessage(), result.getException());

 
         } finally {
             if (propfind != null)
 
         } finally {
             if (propfind != null)


@@ -72,8 +156,41 @@ public class SynchronizeFileOperation extends RemoteOperation {
         }
         return result;
     }
         }
         return result;
     }

+

     
     /**
     
     /**

+     * Requests for an upload to the FileUploader service
+     * 
+     * @param file     OCFile object representing the file to upload
+     */
+    private void requestForUpload(OCFile file) {
+        Intent i = new Intent(mContext, FileUploader.class);
+        i.putExtra(FileUploader.KEY_ACCOUNT, mAccount);
+        i.putExtra(FileUploader.KEY_FILE, file);
+        /*i.putExtra(FileUploader.KEY_REMOTE_FILE, mRemotePath);    // doing this we would lose the value of keepInSync in the road, and maybe it's not updated in the database when the FileUploader service gets it!  
+        i.putExtra(FileUploader.KEY_LOCAL_FILE, localFile.getStoragePath());*/
+        i.putExtra(FileUploader.KEY_UPLOAD_TYPE, FileUploader.UPLOAD_SINGLE_FILE);
+        i.putExtra(FileUploader.KEY_FORCE_OVERWRITE, true);
+        mContext.startService(i);
+        mTransferWasRequested = true;
+    }
+
+
+    /**
+     * Requests for a download to the FileDownloader service
+     * 
+     * @param file     OCFile object representing the file to download
+     */
+    private void requestForDownload(OCFile file) {
+        Intent i = new Intent(mContext, FileDownloader.class);
+        i.putExtra(FileDownloader.EXTRA_ACCOUNT, mAccount);
+        i.putExtra(FileDownloader.EXTRA_FILE, file);
+        mContext.startService(i);
+        mTransferWasRequested = true;
+    }
+
+
+    /**

      * Creates and populates a new {@link OCFile} object with the data read from the server.
      * 
      * @param we        WebDAV entry read from the server for a WebDAV resource (remote file or folder).
      * Creates and populates a new {@link OCFile} object with the data read from the server.
      * 
      * @param we        WebDAV entry read from the server for a WebDAV resource (remote file or folder).


@@ -85,8 +202,14 @@ public class SynchronizeFileOperation extends RemoteOperation {
         file.setFileLength(we.contentLength());
         file.setMimetype(we.contentType());
         file.setModificationTimestamp(we.modifiedTimesamp());
         file.setFileLength(we.contentLength());
         file.setMimetype(we.contentType());
         file.setModificationTimestamp(we.modifiedTimesamp());

-        file.setLastSyncDate(System.currentTimeMillis());
+        file.setLastSyncDateForProperties(System.currentTimeMillis());
+        file.setLastSyncDateForData(0);

         return file;
     }
 
         return file;
     }
 

+
+    public boolean transferWasRequested() {
+        return mTransferWasRequested;
+    }
+

 }
 }