Adapt UploadDBObject (new OCUpload) to manage uploads data

src/com/owncloud/android/datamodel/OCFile.java

@@ -24,7 +24,6 @@ package com.owncloud.android.datamodel;
 
 
 import java.io.File;
-import java.io.Serializable;
 
 import android.content.ContentResolver;
 import android.net.Uri;
@@ -36,15 +35,7 @@ import com.owncloud.android.lib.common.utils.Log_OC;
 
 import third_parties.daveKoeller.AlphanumComparator;
 
-// OCFile needs to be Serializable because it is stored persistently inside UploadDbObject.
-// (Parcelable is not suitable for persistent storage.)
-public class OCFile implements Parcelable, Comparable<OCFile>, Serializable {
-
-    /**
-     * Should be changed whenever any property of OCFile changes.
-     */
-    private static final long serialVersionUID = 3124969637855693659L;
-
+public class OCFile implements Parcelable, Comparable<OCFile> {
 
     public static final Parcelable.Creator<OCFile> CREATOR = new Parcelable.Creator<OCFile>() {
         @Override

src/com/owncloud/android/datamodel/UploadsStorageManager.java

@@ -20,6 +20,7 @@
  */
 package com.owncloud.android.datamodel;
 
+import java.io.File;
 import java.util.Observable;
 
 import android.content.ContentResolver;
@@ -27,10 +28,12 @@ import android.content.ContentValues;
 import android.database.Cursor;
 import android.net.Uri;
 
+import com.owncloud.android.db.OCUpload;
 import com.owncloud.android.db.ProviderMeta.ProviderTableMeta;
-import com.owncloud.android.db.UploadDbObject;
-import com.owncloud.android.lib.common.operations.RemoteOperationResult;
+import com.owncloud.android.db.UploadResult;
+import com.owncloud.android.files.services.FileUploadService;
 import com.owncloud.android.lib.common.utils.Log_OC;
+import com.owncloud.android.utils.FileStorageUtils;
 
 /**
  * Database helper for storing list of files to be uploaded, including status
@@ -80,6 +83,29 @@ public class UploadsStorageManager extends Observable {
         public int getValue() {
             return value;
         }
+
+        public static  UploadStatus fromValue(int value)
+        {
+            switch (value)
+            {
+                case 0:
+                    return UPLOAD_LATER;
+                case 1:
+                    return UPLOAD_FAILED_RETRY;
+                case 2:
+                    return UPLOAD_IN_PROGRESS;
+                case 3:
+                    return UPLOAD_PAUSED;
+                case 4:
+                    return UPLOAD_SUCCEEDED;
+                case 5:
+                    return UPLOAD_FAILED_GIVE_UP;
+                case 6:
+                    return UPLOAD_CANCELLED;
+            }
+            return null;
+        }
+
     };
 
     public UploadsStorageManager(ContentResolver contentResolver) {
@@ -92,22 +118,22 @@ public class UploadsStorageManager extends Observable {
     /**
      * Stores an upload object in DB.
      * 
-     * @param uploadObject
+     * @param ocUpload
      * @return true on success.
      */
-    public boolean storeUpload(UploadDbObject uploadObject) {
-        Log_OC.e(TAG, "Inserting " + uploadObject.getLocalPath() + " with uploadStatus=" + uploadObject.getUploadStatus());
+    public boolean storeUpload(OCUpload ocUpload) {
+        Log_OC.e(TAG, "Inserting " + ocUpload.getLocalPath() + " with status=" + ocUpload.getUploadStatus());
         
         ContentValues cv = new ContentValues();
-        cv.put(ProviderTableMeta.UPLOADS_PATH, uploadObject.getLocalPath());
-        cv.put(ProviderTableMeta.UPLOADS_STATUS, uploadObject.getUploadStatus().value);
-        // TODO - CRITICAL cv.put("uploadObject", uploadObject.toString());
+        cv.put(ProviderTableMeta.UPLOADS_PATH, ocUpload.getLocalPath());
+        cv.put(ProviderTableMeta.UPLOADS_STATUS, ocUpload.getUploadStatus().value);
+        cv.put(ProviderTableMeta.UPLOADS_FILE_ID, ocUpload.getOCFile().getFileId());
 
         Uri result = getDB().insert(ProviderTableMeta.CONTENT_URI_UPLOADS, cv);
         
-        Log_OC.d(TAG, "storeUpload returns with: " + result + " for file: " + uploadObject.getLocalPath());
+        Log_OC.d(TAG, "storeUpload returns with: " + result + " for file: " + ocUpload.getLocalPath());
         if (result == null) {
-            Log_OC.e(TAG, "Failed to insert item " + uploadObject.getLocalPath() + " into upload db.");
+            Log_OC.e(TAG, "Failed to insert item " + ocUpload.getLocalPath() + " into upload db.");
             return false;
         } else {
             notifyObserversNow();
@@ -120,39 +146,40 @@ public class UploadsStorageManager extends Observable {
      * 
      * @return 1 if file status was updated, else 0.
      */
-    public int updateUploadStatus(UploadDbObject uploadDbObject) {
-        return updateUploadStatus(uploadDbObject.getLocalPath(), uploadDbObject.getUploadStatus(),
-                uploadDbObject.getLastResult());
+    public int updateUploadStatus(OCUpload ocUpload) {
+        return updateUploadStatus(ocUpload.getLocalPath(), ocUpload.getUploadStatus(),
+                ocUpload.getLastResult());
     }
 
-    private int updateUploadInternal(Cursor c, UploadStatus status, RemoteOperationResult result) {
+    private int updateUploadInternal(Cursor c, UploadStatus status, UploadResult result) {
         
         while(c.moveToNext()) {
             // read upload object and update
-            String uploadObjectString = c.getString(c.getColumnIndex("uploadObject"));
-            UploadDbObject uploadObject = UploadDbObject.fromString(uploadObjectString);
-            
-            String path = c.getString(c.getColumnIndex("path"));
+            OCUpload upload = createOCUploadFromCursor(c);
+
+            String path = c.getString(c.getColumnIndex(ProviderTableMeta.UPLOADS_PATH));
             Log_OC.v(
                     TAG,
                     "Updating " + path + " with status:" + status + " and result:"
-                            + (result == null ? "null" : result.getCode()) + " (old:"
-                            + uploadObject.toFormattedString() + ")");
+                            + (result == null ? "null" : result.toString()) + " (old:"
+                            + upload.toFormattedString() + ")");
 
-            uploadObject.setUploadStatus(status);
-            uploadObject.setLastResult(result);
-            uploadObjectString = uploadObject.toString();
+            upload.setUploadStatus(status);
+            upload.setLastResult(result);
             // store update upload object to db
+            updateUploadStatus(upload);
             ContentValues cv = new ContentValues();
             cv.put(ProviderTableMeta.UPLOADS_STATUS, status.value);
-            // TODO - CRITICAL cv.put("uploadObject", uploadObjectString);
-
-            int r = getDB().update(
-                    ProviderTableMeta.CONTENT_URI_UPLOADS,
-                    cv,
-                    ProviderTableMeta.UPLOADS_PATH + "=?",
-                    new String[] {path}
-            );
+            int r = updateUploadStatus(upload);
+            // TODO - CRITICAL cv.put("ocUpload", uploadObjectString);
+
+            // TODO: review if it is needed or not
+//            int r = getDB().update(
+//                    ProviderTableMeta.CONTENT_URI_UPLOADS,
+//                    cv,
+//                    ProviderTableMeta.UPLOADS_PATH + "=?",
+//                    new String[] {path}
+//            );
             
             if (r == 1) {
                 notifyObserversNow();
@@ -171,7 +198,7 @@ public class UploadsStorageManager extends Observable {
      * @param result new result of upload operation
      * @return 1 if file status was updated, else 0.
      */
-    public int updateUploadStatus(String filepath, UploadStatus status, RemoteOperationResult result) {
+    public int updateUploadStatus(String filepath, UploadStatus status, UploadResult result) {
         //Log_OC.e(TAG, "Updating "+filepath+" with uploadStatus="+status +" and result="+result);
         
         Cursor c = getDB().query(
@@ -210,8 +237,8 @@ public class UploadsStorageManager extends Observable {
     public int removeUpload(String localPath) {
         int result = getDB().delete(
                 ProviderTableMeta.CONTENT_URI_UPLOADS,
-                ProviderTableMeta.UPLOADS_PATH,
-                new String[] { localPath }
+                ProviderTableMeta.UPLOADS_PATH + "=?",
+                new String[]{localPath}
         );
         Log_OC.d(TAG, "delete returns with: " + result + " for file: " + localPath);
         if(result > 0) {
@@ -220,16 +247,16 @@ public class UploadsStorageManager extends Observable {
         return result;
     }
 
-    public UploadDbObject[] getAllStoredUploads() {
+    public OCUpload[] getAllStoredUploads() {
         return getUploads(null, null);
     }
     
-    public UploadDbObject[] getUploadByLocalPath(String localPath) {
-        return getUploads("path = ?", new String[] { localPath });
+    public OCUpload[] getUploadByLocalPath(String localPath) {
+        return getUploads(ProviderTableMeta.UPLOADS_PATH +"=?", new String[]{localPath});
     }
 
 
-    private UploadDbObject[] getUploads(String selection, String[] selectionArgs) {
+    private OCUpload[] getUploads(String selection, String[] selectionArgs) {
         Cursor c = getDB().query(
                 ProviderTableMeta.CONTENT_URI_UPLOADS,
                 null,
@@ -237,63 +264,170 @@ public class UploadsStorageManager extends Observable {
                 selectionArgs,
                 null
         );
-        UploadDbObject[] list = new UploadDbObject[c.getCount()];
+        OCUpload[] list = new OCUpload[c.getCount()];
         if (c.moveToFirst()) {
             do {
-                String uploadObjectString = c.getString(c.getColumnIndex("uploadObject"));
-                UploadDbObject uploadObject = UploadDbObject.fromString(uploadObjectString);
-                if (uploadObject == null) {
-                    Log_OC.e(TAG, "Could not deserialize UploadDbObject " + uploadObjectString);
+                long fileUploadId = c.getLong(c.getColumnIndex(ProviderTableMeta.UPLOADS_FILE_ID));
+                // getFile for this fileUploadId
+                OCFile file = getUploadFile(fileUploadId);
+                OCUpload upload = new OCUpload(file);
+                if (upload == null) {
+                    Log_OC.e(TAG, "Upload for file id = " + fileUploadId + "not found on DB");
                 } else {
-                    list[c.getPosition()] = uploadObject;
+                    list[c.getPosition()] = upload;
                 }
             } while (c.moveToNext());
         }
         return list;
     }
 
+    private OCFile getUploadFile(long id) {
+        OCFile file = null;
+        Cursor c = getDB().query(
+                ProviderTableMeta.CONTENT_URI_FILE,
+                null,
+                ProviderTableMeta._ID + "=?",
+                new String[]{ String.valueOf(id) },
+                null
+        );
+
+        if (c.moveToFirst()) {
+            file = createFileInstance(c);
+        }
+
+        return file;
+    }
+
+    private OCFile createFileInstance(Cursor c) {
+        OCFile file = null;
+        if (c != null) {
+            file = new OCFile(c.getString(c
+                    .getColumnIndex(ProviderTableMeta.FILE_PATH)));
+            file.setFileId(c.getLong(c.getColumnIndex(ProviderTableMeta._ID)));
+            file.setParentId(c.getLong(c
+                    .getColumnIndex(ProviderTableMeta.FILE_PARENT)));
+            file.setMimetype(c.getString(c
+                    .getColumnIndex(ProviderTableMeta.FILE_CONTENT_TYPE)));
+            if (!file.isFolder()) {
+                file.setStoragePath(c.getString(c
+                        .getColumnIndex(ProviderTableMeta.FILE_STORAGE_PATH)));
+                if (file.getStoragePath() == null) {
+                    // try to find existing file and bind it with current account;
+                    // with the current update of SynchronizeFolderOperation, this won't be
+                    // necessary anymore after a full synchronization of the account
+                    String accountName = c.getString(c
+                            .getColumnIndex(ProviderTableMeta.FILE_ACCOUNT_OWNER));
+                    File f = new File(FileStorageUtils.getDefaultSavePathFor(accountName, file));
+                    if (f.exists()) {
+                        file.setStoragePath(f.getAbsolutePath());
+                        file.setLastSyncDateForData(f.lastModified());
+                    }
+                }
+            }
+            file.setFileLength(c.getLong(c
+                    .getColumnIndex(ProviderTableMeta.FILE_CONTENT_LENGTH)));
+            file.setCreationTimestamp(c.getLong(c
+                    .getColumnIndex(ProviderTableMeta.FILE_CREATION)));
+            file.setModificationTimestamp(c.getLong(c
+                    .getColumnIndex(ProviderTableMeta.FILE_MODIFIED)));
+            file.setModificationTimestampAtLastSyncForData(c.getLong(c
+                    .getColumnIndex(ProviderTableMeta.FILE_MODIFIED_AT_LAST_SYNC_FOR_DATA)));
+            file.setLastSyncDateForProperties(c.getLong(c
+                    .getColumnIndex(ProviderTableMeta.FILE_LAST_SYNC_DATE)));
+            file.setLastSyncDateForData(c.getLong(c.
+                    getColumnIndex(ProviderTableMeta.FILE_LAST_SYNC_DATE_FOR_DATA)));
+            file.setFavorite(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.FILE_KEEP_IN_SYNC)) == 1 ? true : false);
+            file.setEtag(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_ETAG)));
+            file.setShareViaLink(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.FILE_SHARED_VIA_LINK)) == 1 ? true : false);
+            file.setShareWithSharee(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.FILE_SHARED_WITH_SHAREE)) == 1 ? true : false);
+            file.setPublicLink(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PUBLIC_LINK)));
+            file.setPermissions(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_PERMISSIONS)));
+            file.setRemoteId(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_REMOTE_ID)));
+            file.setNeedsUpdateThumbnail(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.FILE_UPDATE_THUMBNAIL)) == 1 ? true : false);
+            file.setDownloading(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.FILE_IS_DOWNLOADING)) == 1 ? true : false);
+            file.setEtagInConflict(c.getString(c.getColumnIndex(ProviderTableMeta.FILE_ETAG_IN_CONFLICT)));
+
+        }
+        return file;
+    }
+
+    private OCUpload createOCUploadFromCursor(Cursor c){
+        OCUpload upload = null;
+        if (c != null){
+            long fileUploadId = c.getLong(c.getColumnIndex(ProviderTableMeta.UPLOADS_FILE_ID));
+            //String uploadObjectString = c.getString(c.getColumnIndex("uploadObject"));
+            // getFile for this fileUploadId
+            OCFile file = getUploadFile(fileUploadId);
+            upload = new OCUpload(file);
+            upload.setUploadId(c.getLong(c.getColumnIndex(ProviderTableMeta._ID)));
+            upload.setUploadStatus(UploadStatus.fromValue(c.getInt(c.getColumnIndex(ProviderTableMeta.UPLOADS_STATUS))));
+            upload.setAccountName(c.getString(c.getColumnIndex(ProviderTableMeta.UPLOADS_ACCOUNT_NAME)));
+            upload.setLocalAction(FileUploadService.LocalBehaviour.fromValue(
+                    c.getInt(c.getColumnIndex((ProviderTableMeta.UPLOADS_LOCAL_BEHAVIOUR)))));
+            upload.setUploadId(c.getLong(c.getColumnIndex(ProviderTableMeta.UPLOADS_UPLOAD_TIME)));
+            upload.setForceOverwrite(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.UPLOADS_FORCE_OVERWRITE)) == 1 ? true : false);
+            upload.setCreateRemoteFolder(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.UPLOADS_IS_CREATE_REMOTE_FOLDER)) == 1 ? true : false);
+            upload.setWhileChargingOnly(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.UPLOADS_IS_WHILE_CHARGING_ONLY)) == 1 ? true : false);
+            upload.setUseWifiOnly(c.getInt(
+                    c.getColumnIndex(ProviderTableMeta.UPLOADS_IS_WIFI_ONLY)) == 1 ? true : false);
+            upload.setLastResult(UploadResult.fromValue(
+                    c.getInt(c.getColumnIndex(ProviderTableMeta.UPLOADS_LAST_RESULT))));
+        }
+        return upload;
+    }
+
     /**
      * Get all uploads which are pending, i.e., queued for upload but not
      * currently being uploaded
      * 
      * @return
      */
-    public UploadDbObject[] getPendingUploads() {
-        return getUploads("uploadStatus==" + UploadStatus.UPLOAD_LATER.value + " OR uploadStatus=="
-                + UploadStatus.UPLOAD_FAILED_RETRY.value, null);
+    public OCUpload[] getPendingUploads() {
+        return getUploads(ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_LATER.value + " OR " +
+                ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_FAILED_RETRY.value,
+                null);
     }
 
     /**
      * Get all uploads which are currently being uploaded. There should only be
      * one. No guarantee though.
      */
-    public UploadDbObject[] getCurrentUpload() {
-        return getUploads("uploadStatus==" + UploadStatus.UPLOAD_IN_PROGRESS.value, null);
+    public OCUpload[] getCurrentUpload() {
+        return getUploads(ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_IN_PROGRESS.value, null);
     }
 
     /**
      * Get all current and pending uploads.
      */
-    public UploadDbObject[] getCurrentAndPendingUploads() {
-        return getUploads("uploadStatus==" + UploadStatus.UPLOAD_IN_PROGRESS.value + " OR uploadStatus=="
-                + UploadStatus.UPLOAD_LATER.value + " OR uploadStatus==" + UploadStatus.UPLOAD_FAILED_RETRY.value
-                + " OR uploadStatus==" + UploadStatus.UPLOAD_PAUSED.value, null);
+    public OCUpload[] getCurrentAndPendingUploads() {
+        return getUploads(ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_IN_PROGRESS.value + " OR " +
+                ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_LATER.value + " OR " +
+                ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_FAILED_RETRY.value + " OR " +
+                ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_PAUSED.value, null);
     }
 
     /**
      * Get all unrecoverably failed. Upload of these should/must/will not be
      * retried.
      */
-    public UploadDbObject[] getFailedUploads() {
-        return getUploads("uploadStatus==" + UploadStatus.UPLOAD_FAILED_GIVE_UP.value + " OR uploadStatus=="
-                + UploadStatus.UPLOAD_CANCELLED.value, null);
+    public OCUpload[] getFailedUploads() {
+        return getUploads(ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_FAILED_GIVE_UP.value + " OR " +
+                ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_CANCELLED.value, null);
     }
 
     /**
      * Get all uploads which where successfully completed.
      */
-    public UploadDbObject[] getFinishedUploads() {
-        return getUploads("uploadStatus==" + UploadStatus.UPLOAD_SUCCEEDED.value, null);
+    public OCUpload[] getFinishedUploads() {
+        return getUploads(ProviderTableMeta.UPLOADS_STATUS + "==" + UploadStatus.UPLOAD_SUCCEEDED.value, null);
     }
 
     private ContentResolver getDB() {

src/com/owncloud/android/db/UploadDbObject.java → src/com/owncloud/android/db/OCUpload.java

@@ -20,59 +20,91 @@
 
 package com.owncloud.android.db;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
-import java.util.Calendar;
-import java.util.GregorianCalendar;
-
 import android.accounts.Account;
 import android.content.Context;
-import android.util.Base64;
 
 import com.owncloud.android.authentication.AccountUtils;
 import com.owncloud.android.datamodel.OCFile;
 import com.owncloud.android.datamodel.UploadsStorageManager;
 import com.owncloud.android.datamodel.UploadsStorageManager.UploadStatus;
 import com.owncloud.android.files.services.FileUploadService.LocalBehaviour;
-import com.owncloud.android.lib.common.operations.RemoteOperationResult;
-import com.owncloud.android.lib.common.utils.Log_OC;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
 
 /**
  * Stores all information in order to start upload operations. PersistentUploadObject can
  * be stored persistently by {@link UploadsStorageManager}.
  * 
  */
-public class UploadDbObject implements Serializable {
+public class OCUpload {
 
     /** Generated - should be refreshed every time the class changes!! */
-    private static final long serialVersionUID = -2306246191385279928L;
+//    private static final long serialVersionUID = 2647551318657321611L;
 
-    private static final String TAG = UploadDbObject.class.getSimpleName();
-    
-    public UploadDbObject(OCFile ocFile) {
-        this.mFile = ocFile;
-    }
+    private static final String TAG = OCUpload.class.getSimpleName();
 
+    private long mId;
 
-    OCFile mFile;
-    
-    public OCFile getOCFile() {
-        return mFile;
-    }
-    
-    
+    private OCFile mFile;
     /**
      * Local action for upload.
      */
-    LocalBehaviour mLocalAction;
-
+    private LocalBehaviour mLocalAction;
     /**
      * Date and time when this upload was first requested.
      */
-    Calendar mUploadTime = new GregorianCalendar();
+    private Calendar mUploadTime = new GregorianCalendar();
+    /**
+     * Overwrite destination file?
+     */
+    private boolean mForceOverwrite;
+    /**
+     * Create destination folder?
+     */
+    private boolean mIsCreateRemoteFolder;
+    /**
+     * Upload only via wifi?
+     */
+    private boolean mIsUseWifiOnly;
+    /**
+     * Upload only if phone being charged?
+     */
+    private boolean mIsWhileChargingOnly;
+    /**
+     * Earliest time when upload may be started. Negative if not set.
+     */
+    private long mUploadTimestamp;
+    /**
+     * Name of Owncloud account to upload file to.
+     */
+    private String mAccountName;
+    /**
+     * Status of upload (later, in_progress, ...).
+     */
+    private UploadStatus mUploadStatus;
+    /**
+     * Result from last upload operation. Can be null.
+     */
+    private UploadResult mLastResult;
+
+    // Constructor
+    public OCUpload(OCFile ocFile) {
+        this.mFile = ocFile;
+    }
+
+
+    // Getters & Setters
+    public void setUploadId(long id) {
+        mId = id;
+    }
+    public long getUploadId() {
+        return mId;
+    }
+
+    public OCFile getOCFile() {
+        return mFile;
+    }
 
     public Calendar getUploadTime() {
         return mUploadTime;
@@ -97,52 +129,17 @@ public class UploadDbObject implements Serializable {
     /**
      * @return the lastResult
      */
-    public RemoteOperationResult getLastResult() {
+    public UploadResult getLastResult() {
         return mLastResult;
     }
 
     /**
      * @param lastResult the lastResult to set
      */
-    public void setLastResult(RemoteOperationResult lastResult) {
+    public void setLastResult(UploadResult lastResult) {
         this.mLastResult = lastResult;
     }
 
-    /**
-     * Overwrite destination file?
-     */
-    boolean mForceOverwrite;
-    /**
-     * Create destination folder?
-     */
-    boolean mIsCreateRemoteFolder;
-    /**
-     * Upload only via wifi?
-     */
-    boolean mIsUseWifiOnly;
-    /**
-     * Upload only if phone being charged?
-     */
-    boolean mIsWhileChargingOnly;
-    /**
-     * Earliest time when upload may be started. Negative if not set.
-     */
-    long mUploadTimestamp;
-
-    /**
-     * Name of Owncloud account to upload file to.
-     */
-    String mAccountName;
-
-    /**
-     * Status of upload (later, in_progress, ...).
-     */
-    UploadStatus mUploadStatus;
-
-    /**
-     * Result from last upload operation. Can be null.
-     */
-    RemoteOperationResult mLastResult;
 
     /**
      * @return the localPath
@@ -165,7 +162,6 @@ public class UploadDbObject implements Serializable {
         return mFile.getMimetype();
     }
 
-
     /**
      * @return the localAction
      */
@@ -236,49 +232,7 @@ public class UploadDbObject implements Serializable {
     public void setAccountName(String accountName) {
         this.mAccountName = accountName;
     }
-
-    /**
-     * Returns a base64 encoded serialized string of this object.
-     */
-    @Override
-    public String toString() {
-        // serialize the object
-        try {
-            ByteArrayOutputStream bo = new ByteArrayOutputStream();
-            ObjectOutputStream so = new ObjectOutputStream(bo);
-            so.writeObject(this);
-            so.flush();
-            String serializedObjectBase64 = Base64.encodeToString(bo.toByteArray(), Base64.DEFAULT);
-            so.close();
-            bo.close();
-            return serializedObjectBase64;
-        } catch (Exception e) {
-            Log_OC.e(TAG, "Cannot serialize UploadDbObject with localPath:" + getLocalPath(), e);
-        }
-        return null;
-    }
-
-    /**
-     * Accepts a base64 encoded serialized string of an {@link UploadDbObject}
-     * and instantiates and returns an according object.
-     * 
-     * @param serializedObjectBase64
-     * @return
-     */
-    static public UploadDbObject fromString(String serializedObjectBase64) {
-        // deserialize the object
-        try {
-            byte[] b = Base64.decode(serializedObjectBase64, Base64.DEFAULT);
-            ByteArrayInputStream bi = new ByteArrayInputStream(b);
-            ObjectInputStream si = new ObjectInputStream(bi);
-            UploadDbObject obj = (UploadDbObject) si.readObject();
-            return obj;
-        } catch (Exception e) {
-            Log_OC.e(TAG, "Cannot deserialize UploadDbObject " + serializedObjectBase64, e);
-        }
-        return null;
-    }
-
+    
     /**
      * Returns owncloud account as {@link Account} object.  
      */
@@ -314,8 +268,9 @@ public class UploadDbObject implements Serializable {
      * For debugging purposes only.
      */
     public String toFormattedString() {
-        return getLocalPath() + " status:" + getUploadStatus() + " result:" +
-                (getLastResult() == null?"null" : getLastResult().getCode());
+        String localPath = getLocalPath()!= null ? getLocalPath() : "";
+        return localPath+ " status:" + getUploadStatus() + " result:" +
+                (getLastResult() == null?"null" : getLastResult().getValue());
     }
 
     /**

src/com/owncloud/android/db/ProviderMeta.java

@@ -137,6 +137,15 @@ public class ProviderMeta {
         public static final String UPLOADS_FILE_ID = "file_id";
         public static final String UPLOADS_PATH = "path";
         public static final String UPLOADS_STATUS = "status";
+        public static final String UPLOADS_ACCOUNT_NAME = "account_name";
+        public static final String UPLOADS_LOCAL_BEHAVIOUR = "local_behaviour";
+        public static final String UPLOADS_UPLOAD_TIME = "upload_time";
+        public static final String UPLOADS_FORCE_OVERWRITE = "force_overwrite";
+        public static final String UPLOADS_IS_CREATE_REMOTE_FOLDER = "is_create_remote_folder";
+        public static final String UPLOADS_IS_WHILE_CHARGING_ONLY = "is_while_charging_only";
+        public static final String UPLOADS_IS_WIFI_ONLY = "is_wifi_only";
+        public static final String UPLOADS_UPLOAD_TIMESTAMP = "upload_timestamp";
+        public static final String UPLOADS_LAST_RESULT = "last_result";
 
         public static final String UPLOADS_DEFAULT_SORT_ORDER = UPLOADS_FILE_ID  + " collate nocase asc";
     }

src/com/owncloud/android/db/UploadResult.java

@@ -0,0 +1,48 @@
+package com.owncloud.android.db;
+
+/**
+ * Created by masensio on 14/12/2015.
+ */
+public enum UploadResult {
+    UPLOADED(0),
+    NETWORK_CONNECTION(1),
+    CREDENTIAL_ERROR(2),
+    FOLDER_ERROR(3),
+    CONFLICT_ERROR(4),
+    FILE_ERROR(5),
+    PRIVILEDGES_ERROR(6),
+    CANCELLED(7);
+
+    private final int value;
+
+    UploadResult(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+    public static UploadResult fromValue(int value)
+    {
+        switch (value)
+        {
+            case 0:
+                return UPLOADED;
+            case 1:
+                return NETWORK_CONNECTION;
+            case 2:
+                return CREDENTIAL_ERROR;
+            case 3:
+                return FOLDER_ERROR;
+            case 4:
+                return CONFLICT_ERROR;
+            case 5:
+                return FILE_ERROR;
+            case 6:
+                return PRIVILEDGES_ERROR;
+            case 7:
+                return CANCELLED;
+        }
+        return null;
+    }
+}

src/com/owncloud/android/files/FileOperationsHelper.java

@@ -36,10 +36,9 @@ import android.widget.Toast;
 import com.owncloud.android.R;
 import com.owncloud.android.authentication.AccountUtils;
 import com.owncloud.android.datamodel.OCFile;
-import com.owncloud.android.db.UploadDbObject;
+import com.owncloud.android.db.OCUpload;
 import com.owncloud.android.files.services.FileDownloader.FileDownloaderBinder;
 import com.owncloud.android.files.services.FileUploadService.FileUploaderBinder;
-import com.owncloud.android.lib.common.accounts.AccountUtils.Constants;
 import com.owncloud.android.lib.common.network.WebdavUtils;
 import com.owncloud.android.lib.common.utils.Log_OC;
 import com.owncloud.android.lib.resources.shares.ShareType;
@@ -508,7 +507,7 @@ public class FileOperationsHelper {
     /**
      * Retry uploading a failed or cancelled upload with force.
      */
-    public void retryUpload(UploadDbObject upload) {
+    public void retryUpload(OCUpload upload) {
         Account account = mFileActivity.getAccount();
         FileUploaderBinder uploaderBinder = mFileActivity.getFileUploaderBinder();
         if (uploaderBinder != null) {
@@ -522,7 +521,7 @@ public class FileOperationsHelper {
     /**
      * Remove upload from upload list.
      */
-    public void removeUploadFromList(UploadDbObject upload) {
+    public void removeUploadFromList(OCUpload upload) {
         Account account = mFileActivity.getAccount();
         FileUploaderBinder uploaderBinder = mFileActivity.getFileUploaderBinder();
         if (uploaderBinder != null) {

src/com/owncloud/android/files/services/FileUploadService.java

@@ -60,7 +60,8 @@ import com.owncloud.android.datamodel.FileDataStorageManager;
 import com.owncloud.android.datamodel.OCFile;
 import com.owncloud.android.datamodel.UploadsStorageManager;
 import com.owncloud.android.datamodel.UploadsStorageManager.UploadStatus;
-import com.owncloud.android.db.UploadDbObject;
+import com.owncloud.android.db.OCUpload;
+import com.owncloud.android.db.UploadResult;
 import com.owncloud.android.lib.common.OwnCloudAccount;
 import com.owncloud.android.lib.common.OwnCloudClient;
 import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
@@ -191,6 +192,19 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         public int getValue() {
             return value;
         }
+
+        public static LocalBehaviour fromValue(int value){
+            switch (value)
+            {
+                case 0:
+                    return LOCAL_BEHAVIOUR_COPY;
+                case 1:
+                    return LOCAL_BEHAVIOUR_MOVE;
+                case 2:
+                    return LOCAL_BEHAVIOUR_FORGET;
+            }
+            return null;
+        }
     }
     
     public enum UploadQuantity {
@@ -222,7 +236,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
      * List of uploads that are currently pending. Maps from remotePath to where file
      * is being uploaded to {@link UploadFileOperation}.
      */
-    private ConcurrentMap<String, UploadDbObject> mPendingUploads = new ConcurrentHashMap<String, UploadDbObject>();
+    private ConcurrentMap<String, OCUpload> mPendingUploads = new ConcurrentHashMap<String, OCUpload>();
     
     /**
      * {@link UploadFileOperation} object of ongoing upload. Can be null. Note: There can only be one concurrent upload!
@@ -255,8 +269,8 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         return account.name + remotePath;
     }
 
-    private String buildRemoteName(UploadDbObject uploadDbObject) {
-        return uploadDbObject.getAccountName() + uploadDbObject.getRemotePath();
+    private String buildRemoteName(OCUpload OCUpload) {
+        return OCUpload.getAccountName() + OCUpload.getRemotePath();
     }
 
     /**
@@ -349,7 +363,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
      * caller activity goes away.
      * 
      * First, onHandleIntent() stores all information associated with the upload
-     * in a {@link UploadDbObject} which is stored persistently using
+     * in a {@link OCUpload} which is stored persistently using
      * {@link UploadsStorageManager}. Then, the oldest, pending upload from
      * {@link UploadsStorageManager} is taken and upload is started.
      * @param intentStartId 
@@ -364,14 +378,14 @@ public class FileUploadService extends Service implements OnDatatransferProgress
             // retry of pending upload was requested. 
             // ==> First check persistent uploads, then perform upload.
             int countAddedEntries = 0;
-            UploadDbObject[] list = mUploadsStorageManager.getPendingUploads();
-            for (UploadDbObject uploadDbObject : list) {
-                Log_OC.d(TAG, "Retrieved from DB: " + uploadDbObject.toFormattedString());
+            OCUpload[] list = mUploadsStorageManager.getPendingUploads();
+            for (OCUpload OCUpload : list) {
+                Log_OC.d(TAG, "Retrieved from DB: " + OCUpload.toFormattedString());
                 
-                String uploadKey = buildRemoteName(uploadDbObject);
-                UploadDbObject previous = mPendingUploads.putIfAbsent(uploadKey, uploadDbObject);
+                String uploadKey = buildRemoteName(OCUpload);
+                OCUpload previous = mPendingUploads.putIfAbsent(uploadKey, OCUpload);
                 if(previous == null) {
-                    Log_OC.d(TAG, "mPendingUploads added: " + uploadDbObject.toFormattedString());
+                    Log_OC.d(TAG, "mPendingUploads added: " + OCUpload.toFormattedString());
                     countAddedEntries++;
                 } else {
                     //already pending. ignore.
@@ -458,7 +472,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
             // save always persistently path of upload, so it can be retried if
             // failed.
             for (int i = 0; i < files.length; i++) {
-                UploadDbObject uploadObject = new UploadDbObject(files[i]);
+                OCUpload uploadObject = new OCUpload(files[i]);
                 uploadObject.setAccountName(account.name);
                 uploadObject.setForceOverwrite(forceOverwrite);
                 uploadObject.setCreateRemoteFolder(isCreateRemoteFolder);
@@ -469,7 +483,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
                 uploadObject.setUploadStatus(UploadStatus.UPLOAD_LATER);
                 
                 String uploadKey = buildRemoteName(uploadObject);
-                UploadDbObject previous = mPendingUploads.putIfAbsent(uploadKey, uploadObject);
+                OCUpload previous = mPendingUploads.putIfAbsent(uploadKey, uploadObject);
                 
                 if(previous == null)
                 {
@@ -507,10 +521,10 @@ public class FileUploadService extends Service implements OnDatatransferProgress
             list.add(remotePath);
             it = list.iterator();
             // update db status for upload
-            UploadDbObject uploadDbObject = mPendingUploads.get(remotePath);
-            uploadDbObject.setUploadStatus(UploadStatus.UPLOAD_LATER);
-            uploadDbObject.setLastResult(null);
-            mUploadsStorageManager.updateUploadStatus(uploadDbObject);
+            OCUpload OCUpload = mPendingUploads.get(remotePath);
+            OCUpload.setUploadStatus(UploadStatus.UPLOAD_LATER);
+            OCUpload.setLastResult(null);
+            mUploadsStorageManager.updateUploadStatus(OCUpload);
 
             Log_OC.d(TAG, "Start uploading " + remotePath);
         } else {
@@ -519,14 +533,14 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         if (it.hasNext()) {
             while (it.hasNext()) {
                 String upload = it.next();
-                UploadDbObject uploadDbObject = mPendingUploads.get(upload);
+                OCUpload OCUpload = mPendingUploads.get(upload);
 
-                if (uploadDbObject == null) {
+                if (OCUpload == null) {
                     Log_OC.e(TAG, "Cannot upload null. Fix that!");
                     continue;
                 }
 
-                UploadTask uploadTask = new UploadTask(uploadDbObject);
+                UploadTask uploadTask = new UploadTask(OCUpload);
                 uploadExecutor.submit(uploadTask);
             }
             StopSelfTask stopSelfTask = new StopSelfTask(intentStartId);
@@ -556,22 +570,22 @@ public class FileUploadService extends Service implements OnDatatransferProgress
     }
 
     /**
-     * Tries uploading uploadDbObject, creates notifications, and updates mUploadsStorageManager.
+     * Tries uploading OCUpload, creates notifications, and updates mUploadsStorageManager.
      */
     public class UploadTask implements Runnable {
-        UploadDbObject uploadDbObject;
+        OCUpload OCUpload;
 
-        public UploadTask(UploadDbObject uploadDbObject) {
-            this.uploadDbObject = uploadDbObject;
+        public UploadTask(OCUpload OCUpload) {
+            this.OCUpload = OCUpload;
         }
 
         @Override
         public void run() {
             Log_OC.d(TAG, "mPendingUploads size:" + mPendingUploads.size() + " - before uploading.");
-            switch (canUploadFileNow(uploadDbObject)) {
+            switch (canUploadFileNow(OCUpload)) {
             case NOW:
-                Log_OC.d(TAG, "Calling uploadFile for " + uploadDbObject.getRemotePath());
-                RemoteOperationResult uploadResult = uploadFile(uploadDbObject);
+                Log_OC.d(TAG, "Calling uploadFile for " + OCUpload.getRemotePath());
+                RemoteOperationResult uploadResult = uploadFile(OCUpload);
                 //TODO store renamed upload path?
                 updateDatabaseUploadResult(uploadResult, mCurrentUpload);
                 notifyUploadResult(uploadResult, mCurrentUpload);
@@ -580,7 +594,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
 //                if (!shouldRetryFailedUpload(uploadResult)) {
 //                    Log_OC.d(TAG, "Upload with result " + uploadResult.getCode() + ": " + uploadResult.getLogMessage()
 //                            + " will be abandoned.");
-//                    mPendingUploads.remove(buildRemoteName(uploadDbObject));
+//                    mPendingUploads.remove(buildRemoteName(OCUpload));
 //                }
                 Log_OC.d(TAG, "mCurrentUpload = null");
                 mCurrentUpload = null;
@@ -593,12 +607,12 @@ public class FileUploadService extends Service implements OnDatatransferProgress
                 break;
             case FILE_GONE:
                 mUploadsStorageManager.updateUploadStatus(
-                        uploadDbObject.getLocalPath(),
+                        OCUpload.getLocalPath(),
                         UploadStatus.UPLOAD_FAILED_GIVE_UP,
-                        new RemoteOperationResult(ResultCode.FILE_NOT_FOUND)
+                        com.owncloud.android.db.UploadResult.FILE_ERROR
                 );
-                if (mPendingUploads.remove(uploadDbObject.getRemotePath()) == null) {
-                    Log_OC.w(TAG, "Could remove " + uploadDbObject.getRemotePath()
+                if (mPendingUploads.remove(OCUpload.getRemotePath()) == null) {
+                    Log_OC.w(TAG, "Could remove " + OCUpload.getRemotePath()
                             + " from mPendingUploads because it does not exist.");
                 }
 
@@ -613,23 +627,23 @@ public class FileUploadService extends Service implements OnDatatransferProgress
     }
 
     /**
-     * Returns the reason as String why state of uploadDbObject is LATER. If
+     * Returns the reason as String why state of OCUpload is LATER. If
      * upload state != LATER return null.
      */
-    static public String getUploadLaterReason(Context context, UploadDbObject uploadDbObject) {
+    static public String getUploadLaterReason(Context context, OCUpload OCUpload) {
         StringBuilder reason = new StringBuilder();
         Date now = new Date();
-        if (now.getTime() < uploadDbObject.getUploadTimestamp()) {
-            reason.append("Waiting for " + DisplayUtils.unixTimeToHumanReadable(uploadDbObject.getUploadTimestamp()));
+        if (now.getTime() < OCUpload.getUploadTimestamp()) {
+            reason.append("Waiting for " + DisplayUtils.unixTimeToHumanReadable(OCUpload.getUploadTimestamp()));
         }
-        if (uploadDbObject.isUseWifiOnly() && !UploadUtils.isConnectedViaWiFi(context)) {
+        if (OCUpload.isUseWifiOnly() && !UploadUtils.isConnectedViaWiFi(context)) {
             if (reason.length() > 0) {
                 reason.append(" and wifi connectivity");
             } else {
                 reason.append("Waiting for wifi connectivity");
             }
         }
-        if (uploadDbObject.isWhileChargingOnly() && !UploadUtils.isCharging(context)) {
+        if (OCUpload.isWhileChargingOnly() && !UploadUtils.isCharging(context)) {
             if (reason.length() > 0) {
                 reason.append(" and charging");
             } else {
@@ -640,7 +654,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         if (reason.length() > 1) {
             return reason.toString();
         }
-        if (uploadDbObject.getUploadStatus() == UploadStatus.UPLOAD_LATER) {
+        if (OCUpload.getUploadStatus() == UploadStatus.UPLOAD_LATER) {
             return "Upload is pending and will start shortly.";
         }
         return null;
@@ -709,9 +723,9 @@ public class FileUploadService extends Service implements OnDatatransferProgress
                 Log_OC.d(TAG, "Calling cancel for " + file.getRemotePath() + " while upload is pending.");                
                 // upload not in progress, but pending.
                 // in this case we have to update the db here.
-                UploadDbObject upload = mPendingUploads.remove(buildRemoteName(account, file));
+                OCUpload upload = mPendingUploads.remove(buildRemoteName(account, file));
                 upload.setUploadStatus(UploadStatus.UPLOAD_CANCELLED);
-                upload.setLastResult(new RemoteOperationResult(ResultCode.CANCELLED));
+                upload.setLastResult(UploadResult.CANCELLED);
                 // storagePath inside upload is the temporary path. file
                 // contains the correct path used as db reference.
                 upload.getOCFile().setStoragePath(file.getStoragePath());
@@ -738,7 +752,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         }
 
         public void remove(Account account, OCFile file) {
-            UploadDbObject upload = mPendingUploads.remove(buildRemoteName(account, file));
+            OCUpload upload = mPendingUploads.remove(buildRemoteName(account, file));
             if(upload == null) {
                 Log_OC.e(TAG, "Could not delete upload "+file+" from mPendingUploads.");
             }
@@ -751,7 +765,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         /**
          * Puts upload in upload list and tell FileUploadService to upload items in list. 
          */
-        public void retry(Account account, UploadDbObject upload) {
+        public void retry(Account account, OCUpload upload) {
             String uploadKey = buildRemoteName(upload);
             mPendingUploads.put(uploadKey, upload);
             FileUploadService.retry(getApplicationContext(), uploadKey);
@@ -831,7 +845,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         @Override
         public void onTransferProgress(long progressRate, long totalTransferredSoFar, long totalToTransfer,
                 String localFileName) {
-            Set<Entry<String, UploadDbObject>> uploads = mPendingUploads.entrySet();
+            Set<Entry<String, OCUpload>> uploads = mPendingUploads.entrySet();
             UploadFileOperation currentUpload = mCurrentUpload;
             if (currentUpload == null) {
                 Log_OC.e(TAG, "Found no current upload with remote path " + localFileName + ". Ignore.");
@@ -851,7 +865,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
     
     /**
      * Returns true when the file may be uploaded now. This methods checks all
-     * restraints of the passed {@link UploadDbObject}, these include
+     * restraints of the passed {@link OCUpload}, these include
      * isUseWifiOnly(), check if local file exists, check if file was already
      * uploaded...
      * 
@@ -865,34 +879,34 @@ public class FileUploadService extends Service implements OnDatatransferProgress
      *         entity should remove upload from queue.
      * 
      */
-    private CanUploadFileNowStatus canUploadFileNow(UploadDbObject uploadDbObject) {
+    private CanUploadFileNowStatus canUploadFileNow(OCUpload OCUpload) {
 
-        if (uploadDbObject.getUploadStatus() == UploadStatus.UPLOAD_SUCCEEDED) {
+        if (OCUpload.getUploadStatus() == UploadStatus.UPLOAD_SUCCEEDED) {
             Log_OC.w(TAG, "Already succeeded uploadObject was again scheduled for upload. Fix that!");
             return CanUploadFileNowStatus.ERROR;
         }
 
-        if (uploadDbObject.isUseWifiOnly()
+        if (OCUpload.isUseWifiOnly()
                 && !UploadUtils.isConnectedViaWiFi(getApplicationContext())) {
             Log_OC.d(TAG, "Do not start upload because it is wifi-only.");
             return CanUploadFileNowStatus.LATER;
         }
         
-        if(uploadDbObject.isWhileChargingOnly() && !UploadUtils.isCharging(getApplicationContext())) {
+        if(OCUpload.isWhileChargingOnly() && !UploadUtils.isCharging(getApplicationContext())) {
             Log_OC.d(TAG, "Do not start upload because it is while charging only.");
             return CanUploadFileNowStatus.LATER;
         }
         Date now = new Date();
-        if (now.getTime() < uploadDbObject.getUploadTimestamp()) {
+        if (now.getTime() < OCUpload.getUploadTimestamp()) {
             Log_OC.d(
                     TAG,
                     "Do not start upload because it is schedule for "
-                            + DisplayUtils.unixTimeToHumanReadable(uploadDbObject.getUploadTimestamp()));
+                            + DisplayUtils.unixTimeToHumanReadable(OCUpload.getUploadTimestamp()));
             return CanUploadFileNowStatus.LATER;
         }
         
 
-        if (!new File(uploadDbObject.getLocalPath()).exists()) {
+        if (!new File(OCUpload.getLocalPath()).exists()) {
             Log_OC.d(TAG, "Do not start upload because local file does not exist.");
             return CanUploadFileNowStatus.FILE_GONE;
         }
@@ -907,11 +921,11 @@ public class FileUploadService extends Service implements OnDatatransferProgress
      * 
      * Before uploading starts mCurrentUpload is set.
      * 
-     * @param uploadDbObject Key to access the upload to perform, contained in
+     * @param OCUpload Key to access the upload to perform, contained in
      *            mPendingUploads
      * @return RemoteOperationResult of upload operation.
      */
-    private RemoteOperationResult uploadFile(UploadDbObject uploadDbObject) {
+    private RemoteOperationResult uploadFile(OCUpload OCUpload) {
         
         if (mCurrentUpload != null) {
             Log_OC.e(TAG,
@@ -920,19 +934,19 @@ public class FileUploadService extends Service implements OnDatatransferProgress
         }
         
         AccountManager aMgr = AccountManager.get(this);
-        Account account = uploadDbObject.getAccount(getApplicationContext());
+        Account account = OCUpload.getAccount(getApplicationContext());
         String version = aMgr.getUserData(account, Constants.KEY_OC_VERSION);
         OwnCloudVersion ocv = new OwnCloudVersion(version);
 
         boolean chunked = FileUploadService.chunkedUploadIsSupported(ocv);
         String uploadKey = null;
 
-        uploadKey = buildRemoteName(account, uploadDbObject.getRemotePath());
-        OCFile file = uploadDbObject.getOCFile();
+        uploadKey = buildRemoteName(account, OCUpload.getRemotePath());
+        OCFile file = OCUpload.getOCFile();
         Log_OC.d(TAG, "mCurrentUpload = new UploadFileOperation");
-        mCurrentUpload = new UploadFileOperation(account, file, chunked, uploadDbObject.isForceOverwrite(),
-                uploadDbObject.getLocalAction(), getApplicationContext());
-        if (uploadDbObject.isCreateRemoteFolder()) {
+        mCurrentUpload = new UploadFileOperation(account, file, chunked, OCUpload.isForceOverwrite(),
+                OCUpload.getLocalAction(), getApplicationContext());
+        if (OCUpload.isCreateRemoteFolder()) {
             mCurrentUpload.setRemoteFolderToBeCreated();
         }
         mCurrentUpload.addDatatransferProgressListener((FileUploaderBinder) mBinder);
@@ -1291,7 +1305,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
             mUploadsStorageManager.updateUploadStatus(
                     upload.getOriginalStoragePath(),
                     UploadStatus.UPLOAD_CANCELLED,
-                    uploadResult
+                    UploadResult.CANCELLED
             );
         } else {
 
@@ -1299,7 +1313,7 @@ public class FileUploadService extends Service implements OnDatatransferProgress
                 mUploadsStorageManager.updateUploadStatus(
                         upload.getOriginalStoragePath(),
                         UploadStatus.UPLOAD_SUCCEEDED,
-                        uploadResult
+                        UploadResult.UPLOADED
                 );
             } else {
                 // TODO: Disable for testing of menu actions in uploads view

src/com/owncloud/android/providers/FileContentProvider.java

@@ -845,7 +845,17 @@ public class FileContentProvider extends ContentProvider {
                 + ProviderTableMeta._ID + " INTEGER PRIMARY KEY, "
                 + ProviderTableMeta.UPLOADS_FILE_ID + " INTEGER, "
                 + ProviderTableMeta.UPLOADS_PATH + " TEXT, "
-                + ProviderTableMeta.UPLOADS_STATUS + " INTEGER );" );   // UploadStatus
+                + ProviderTableMeta.UPLOADS_STATUS + " INTEGER, "               // UploadStatus
+                + ProviderTableMeta.UPLOADS_ACCOUNT_NAME + " TEXT, "
+                + ProviderTableMeta.UPLOADS_LOCAL_BEHAVIOUR + " INTEGER, "      // Upload LocalBehaviour
+                + ProviderTableMeta.UPLOADS_UPLOAD_TIME + " INTEGER, "
+                + ProviderTableMeta.UPLOADS_FORCE_OVERWRITE + " INTEGER, "  // boolean
+                + ProviderTableMeta.UPLOADS_IS_CREATE_REMOTE_FOLDER + " INTEGER, "  // boolean
+                + ProviderTableMeta.UPLOADS_IS_WHILE_CHARGING_ONLY + " INTEGER, "  // boolean
+                + ProviderTableMeta.UPLOADS_IS_WIFI_ONLY + "INTEGER, " // boolean
+                + ProviderTableMeta.UPLOADS_UPLOAD_TIMESTAMP + " INTEGER, "
+                + ProviderTableMeta.UPLOADS_LAST_RESULT + " INTEGER );" );     // Upload LastResult
+
 
         /* before:
         // PRIMARY KEY should always imply NOT NULL. Unfortunately, due to a

src/com/owncloud/android/ui/activity/UploadListActivity.java

@@ -38,7 +38,7 @@ import android.widget.Toast;
 import com.owncloud.android.R;
 import com.owncloud.android.datamodel.OCFile;
 import com.owncloud.android.datamodel.UploadsStorageManager;
-import com.owncloud.android.db.UploadDbObject;
+import com.owncloud.android.db.OCUpload;
 import com.owncloud.android.files.services.FileUploadService;
 import com.owncloud.android.files.services.FileUploadService.FileUploaderBinder;
 import com.owncloud.android.lib.common.utils.Log_OC;
@@ -66,7 +66,7 @@ public class UploadListActivity extends FileActivity implements UploadListFragme
     // UploadListFragment.ContainerActivity
     // ////////////////////////////////////////
     @Override
-    public boolean onUploadItemClick(UploadDbObject file) {
+    public boolean onUploadItemClick(OCUpload file) {
         File f = new File(file.getLocalPath());
         if(!f.exists()) {
             Toast.makeText(this, "Cannot open. Local file does not exist.",
@@ -111,7 +111,7 @@ public class UploadListActivity extends FileActivity implements UploadListFragme
      * there is none.
      */
     @SuppressWarnings("unused")
-    private void openPreview(UploadDbObject file) {
+    private void openPreview(OCUpload file) {
      // preview image
         Intent showDetailsIntent = new Intent(this, PreviewImageActivity.class);
         showDetailsIntent.putExtra(EXTRA_FILE, (Parcelable)file.getOCFile());
@@ -120,7 +120,7 @@ public class UploadListActivity extends FileActivity implements UploadListFragme
     }
     
     @SuppressWarnings("unused")
-    private void openDetails(UploadDbObject file) {
+    private void openDetails(OCUpload file) {
         OCFile ocFile = file.getOCFile();
         Intent showDetailsIntent = new Intent(this, FileDisplayActivity.class);
         showDetailsIntent.putExtra(FileActivity.EXTRA_FILE, (Parcelable) ocFile);

src/com/owncloud/android/ui/adapter/ExpandableUploadListAdapter.java

@@ -45,7 +45,7 @@ import com.owncloud.android.datamodel.OCFile;
 import com.owncloud.android.datamodel.ThumbnailsCacheManager;
 import com.owncloud.android.datamodel.UploadsStorageManager;
 import com.owncloud.android.datamodel.UploadsStorageManager.UploadStatus;
-import com.owncloud.android.db.UploadDbObject;
+import com.owncloud.android.db.OCUpload;
 import com.owncloud.android.files.services.FileUploadService;
 import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
 import com.owncloud.android.lib.common.utils.Log_OC;
@@ -60,7 +60,7 @@ import com.owncloud.android.utils.DisplayUtils;
  */
 public class ExpandableUploadListAdapter extends BaseExpandableListAdapter implements Observer {
 
-    private static final String TAG = "ExpandableUploadListAdapter";
+    private static final String TAG = ExpandableUploadListAdapter.class.getSimpleName();
     private FileActivity mParentActivity;
 
     private UploadsStorageManager mUploadsStorageManager;
@@ -72,21 +72,21 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
         public void refresh();
     }
     abstract class UploadGroup implements Refresh {
-        UploadDbObject[] items;
+        OCUpload[] items;
         String name;
         public UploadGroup(String groupName) {
             this.name = groupName;            
-            items = new UploadDbObject[0];
+            items = new OCUpload[0];
         }        
         public String getGroupName() {
             return name;
         }
-        public Comparator<UploadDbObject> comparator = new Comparator<UploadDbObject>() {
+        public Comparator<OCUpload> comparator = new Comparator<OCUpload>() {
             @Override
-            public int compare(UploadDbObject lhs, UploadDbObject rhs) {
+            public int compare(OCUpload lhs, OCUpload rhs) {
                 return compareUploadTime(lhs, rhs);
             }
-            private int compareUploadTime(UploadDbObject lhs, UploadDbObject rhs) {
+            private int compareUploadTime(OCUpload lhs, OCUpload rhs) {
                 return rhs.getUploadTime().compareTo(lhs.getUploadTime());
             }
         };
@@ -156,7 +156,7 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
         return true;
     }
     
-    private View getView(UploadDbObject[] uploadsItems, int position, View convertView, ViewGroup parent) {
+    private View getView(OCUpload[] uploadsItems, int position, View convertView, ViewGroup parent) {
         View view = convertView;
         if (view == null) {
             LayoutInflater inflator =
@@ -166,89 +166,89 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
             view = inflator.inflate(R.layout.upload_list_item, null);
         }
         if (uploadsItems != null && uploadsItems.length > position) {
-            final UploadDbObject uploadObject = uploadsItems[position];
+            final OCUpload upload = uploadsItems[position];
 
             TextView fileName = (TextView) view.findViewById(R.id.upload_name);
-            String file = uploadObject.getOCFile().getFileName();
+            String file = upload.getOCFile().getFileName();
             fileName.setText(file);
             
             TextView localPath = (TextView) view.findViewById(R.id.upload_local_path);
-            String path = uploadObject.getOCFile().getStoragePath();
+            String path = upload.getOCFile().getStoragePath();
             path = path.substring(0, path.length() - file.length() - 1);
             localPath.setText("Path: " + path);
 
             TextView fileSize = (TextView) view.findViewById(R.id.upload_file_size);
-            fileSize.setText(DisplayUtils.bytesToHumanReadable(uploadObject.getOCFile().getFileLength()));
+            fileSize.setText(DisplayUtils.bytesToHumanReadable(upload.getOCFile().getFileLength()));
 
             TextView statusView = (TextView) view.findViewById(R.id.upload_status);
             String status;
-            switch (uploadObject.getUploadStatus()) {
-            case UPLOAD_IN_PROGRESS:
-                status = mParentActivity.getString(R.string.uploader_upload_in_progress_ticker);
-                ProgressBar progressBar = (ProgressBar) view.findViewById(R.id.upload_progress_bar);
-                progressBar.setProgress(0);
-                progressBar.setVisibility(View.VISIBLE);
-                mProgressListener = new ProgressListener(progressBar);
-                if(mParentActivity.getFileUploaderBinder() != null) {
-                    mCurrentUpload = mParentActivity.getFileUploaderBinder().getCurrentUploadOperation();
-                    if(mCurrentUpload != null) {
-                        mCurrentUpload.addDatatransferProgressListener(mProgressListener);
-                        Log_OC.d(TAG, "added progress listener for current upload: " + mCurrentUpload);
+            switch (upload.getUploadStatus()) {
+                case UPLOAD_IN_PROGRESS:
+                    status = mParentActivity.getString(R.string.uploader_upload_in_progress_ticker);
+                    ProgressBar progressBar = (ProgressBar) view.findViewById(R.id.upload_progress_bar);
+                    progressBar.setProgress(0);
+                    progressBar.setVisibility(View.VISIBLE);
+                    mProgressListener = new ProgressListener(progressBar);
+                    if(mParentActivity.getFileUploaderBinder() != null) {
+                        mCurrentUpload = mParentActivity.getFileUploaderBinder().getCurrentUploadOperation();
+                        if(mCurrentUpload != null) {
+                            mCurrentUpload.addDatatransferProgressListener(mProgressListener);
+                            Log_OC.d(TAG, "added progress listener for current upload: " + mCurrentUpload);
+                        } else {
+                            Log_OC.w(TAG, "getFileUploaderBinder().getCurrentUploadOperation() return null. That is odd.");
+                        }
                     } else {
-                        Log_OC.w(TAG, "getFileUploaderBinder().getCurrentUploadOperation() return null. That is odd.");
+                        Log_OC.e(TAG, "UploadBinder == null. It should have been created on creating mParentActivity"
+                                + " which inherits from FileActivity. Fix that!");
                     }
-                } else {
-                    Log_OC.e(TAG, "UploadBinder == null. It should have been created on creating mParentActivity"
-                            + " which inherits from FileActivity. Fix that!");
-                }
-                break;
-            case UPLOAD_FAILED_GIVE_UP:
-                if (uploadObject.getLastResult() != null) {
-                    status = "Upload failed: " + uploadObject.getLastResult().getLogMessage();
-                } else {
-                    status = "Upload failed.";
-                }
-                break;
-            case UPLOAD_FAILED_RETRY:
-                if(uploadObject.getLastResult() != null){
-                    status = "Last failure: "
-                        + uploadObject.getLastResult().getLogMessage();
-                } else {
-                    status = "Upload will be retried shortly.";
-                }
-                String laterReason = FileUploadService.getUploadLaterReason(mParentActivity, uploadObject);
-                if(laterReason != null) {
-                    //Upload failed once but is delayed now, show reason.
-                    status += "\n" + laterReason;
-                }
-                break;
-            case UPLOAD_LATER:
-                status = FileUploadService.getUploadLaterReason(mParentActivity, uploadObject);
-                break;
-            case UPLOAD_SUCCEEDED:
-                status = "Completed.";
-                break;
-            case UPLOAD_CANCELLED:
-                status = "Upload cancelled.";
-                break;
-            case UPLOAD_PAUSED:
-                status = "Upload paused.";
-                break;
-            default:
-                status = uploadObject.getUploadStatus().toString();
-                if(uploadObject.getLastResult() != null){
-                    uploadObject.getLastResult().getLogMessage();
-                } 
-                break;
+                    break;
+                case UPLOAD_FAILED_GIVE_UP:
+                    if (upload.getLastResult() != null) {
+                        status = "Upload failed: " + upload.getLastResult().toString();
+                    } else {
+                        status = "Upload failed.";
+                    }
+                    break;
+                case UPLOAD_FAILED_RETRY:
+                    if(upload.getLastResult() != null){
+                        status = "Last failure: "
+                                + upload.getLastResult().toString();
+                    } else {
+                        status = "Upload will be retried shortly.";
+                    }
+                    String laterReason = FileUploadService.getUploadLaterReason(mParentActivity, upload);
+                    if(laterReason != null) {
+                        //Upload failed once but is delayed now, show reason.
+                        status += "\n" + laterReason;
+                    }
+                    break;
+                case UPLOAD_LATER:
+                    status = FileUploadService.getUploadLaterReason(mParentActivity, upload);
+                    break;
+                case UPLOAD_SUCCEEDED:
+                    status = "Completed.";
+                    break;
+                case UPLOAD_CANCELLED:
+                    status = "Upload cancelled.";
+                    break;
+                case UPLOAD_PAUSED:
+                    status = "Upload paused.";
+                    break;
+                default:
+                    status = upload.getUploadStatus().toString();
+                    if(upload.getLastResult() != null){
+                        upload.getLastResult().toString();
+                    }
+                    break;
             }
-            if(uploadObject.getUploadStatus() != UploadStatus.UPLOAD_IN_PROGRESS) {
+            if(upload.getUploadStatus() != UploadStatus.UPLOAD_IN_PROGRESS) {
                 ProgressBar progressBar = (ProgressBar) view.findViewById(R.id.upload_progress_bar);
                 progressBar.setVisibility(View.GONE);
                 if (mParentActivity.getFileUploaderBinder() != null && mProgressListener != null
                         && mCurrentUpload != null) {
                     OCFile currentOcFile = mCurrentUpload.getFile();
                     mParentActivity.getFileUploaderBinder().removeDatatransferProgressListener(mProgressListener,
-                            uploadObject.getAccount(mParentActivity), currentOcFile);
+                            upload.getAccount(mParentActivity), currentOcFile);
                     mProgressListener = null;
                     mCurrentUpload = null;
                 }            
@@ -256,23 +256,23 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
             statusView.setText(status);
 
             ImageButton rightButton = (ImageButton) view.findViewById(R.id.upload_right_button);
-            if (uploadObject.userCanRetryUpload()
-                    && uploadObject.getUploadStatus() != UploadStatus.UPLOAD_SUCCEEDED) {
+            if (upload.userCanRetryUpload()
+                    && upload.getUploadStatus() != UploadStatus.UPLOAD_SUCCEEDED) {
                 //Refresh   - TODO test buttons in Android 4.x
                 rightButton.setImageDrawable(mParentActivity.getDrawable(R.drawable.ic_action_refresh_grey));
                 rightButton.setOnClickListener(new OnClickListener() {
                     @Override
                     public void onClick(View v) {
-                        mParentActivity.getFileOperationsHelper().retryUpload(uploadObject);
+                        mParentActivity.getFileOperationsHelper().retryUpload(upload);
                     }
                 });
-            } else if (uploadObject.userCanCancelUpload()) {
+            } else if (upload.userCanCancelUpload()) {
                 //Cancel
                 rightButton.setImageDrawable(mParentActivity.getDrawable(R.drawable.ic_cancel));
                 rightButton.setOnClickListener(new OnClickListener() {                
                     @Override
                     public void onClick(View v) {
-                        mParentActivity.getFileOperationsHelper().cancelTransference(uploadObject.getOCFile());
+                        mParentActivity.getFileOperationsHelper().cancelTransference(upload.getOCFile());
                     }
                 });
             } else {
@@ -281,7 +281,7 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
                 rightButton.setOnClickListener(new OnClickListener() {                
                     @Override
                     public void onClick(View v) {
-                        mParentActivity.getFileOperationsHelper().removeUploadFromList(uploadObject);
+                        mParentActivity.getFileOperationsHelper().removeUploadFromList(upload);
                     }
                 });
             }
@@ -290,7 +290,7 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
             ImageView fileIcon = (ImageView) view.findViewById(R.id.imageView1);
             fileIcon.setImageResource(R.drawable.file);
             try {
-                Bitmap b = ThumbnailsCacheManager.getBitmapFromDiskCache(uploadObject.getOCFile().getRemoteId());
+                Bitmap b = ThumbnailsCacheManager.getBitmapFromDiskCache(upload.getOCFile().getRemoteId());
                 if (b != null) {
                     fileIcon.setImageBitmap(b);
                 }
@@ -300,7 +300,7 @@ public class ExpandableUploadListAdapter extends BaseExpandableListAdapter imple
             TextView uploadDate = (TextView) view.findViewById(R.id.upload_date);
             CharSequence dateString = DisplayUtils.getRelativeDateTimeString(
                     mParentActivity,
-                    uploadObject.getUploadTime().getTimeInMillis(),
+                    upload.getUploadTime().getTimeInMillis(),
                     DateUtils.SECOND_IN_MILLIS,
                     DateUtils.WEEK_IN_MILLIS,
                     0

src/com/owncloud/android/ui/fragment/UploadListFragment.java

@@ -35,7 +35,7 @@ import android.widget.ExpandableListView.ExpandableListContextMenuInfo;
 import android.widget.ListView;
 
 import com.owncloud.android.R;
-import com.owncloud.android.db.UploadDbObject;
+import com.owncloud.android.db.OCUpload;
 import com.owncloud.android.lib.common.utils.Log_OC;
 import com.owncloud.android.ui.activity.FileActivity;
 import com.owncloud.android.ui.activity.FileDisplayActivity;
@@ -96,10 +96,10 @@ public class UploadListFragment extends ExpandableListFragment {
     @Override
     public boolean onChildClick(ExpandableListView parent, View v, int groupPosition, int childPosition, long id) {
         boolean handled = false;
-        UploadDbObject uploadDbObject = (UploadDbObject) mAdapter.getChild(groupPosition, childPosition);
-        if (uploadDbObject != null) {
+        OCUpload OCUpload = (OCUpload) mAdapter.getChild(groupPosition, childPosition);
+        if (OCUpload != null) {
             // notify the click to container Activity
-            handled = mContainerActivity.onUploadItemClick(uploadDbObject);
+            handled = mContainerActivity.onUploadItemClick(OCUpload);
         } else {
             Log_OC.w(TAG, "Null object in ListAdapter!!");
         }
@@ -115,7 +115,7 @@ public class UploadListFragment extends ExpandableListFragment {
         ExpandableListContextMenuInfo info = (ExpandableListContextMenuInfo) menuInfo;  
         int childPosition = ExpandableListView.getPackedPositionChild(info.packedPosition);
         int groupPosition = ExpandableListView.getPackedPositionGroup(info.packedPosition);
-        UploadDbObject uploadFile = (UploadDbObject) mAdapter.getChild(groupPosition, childPosition);
+        OCUpload uploadFile = (OCUpload) mAdapter.getChild(groupPosition, childPosition);
         if (uploadFile.userCanCancelUpload()) {
             MenuItem item = menu.findItem(R.id.action_remove_upload);
             if (item != null) {
@@ -143,7 +143,7 @@ public class UploadListFragment extends ExpandableListFragment {
         ExpandableListContextMenuInfo info = (ExpandableListContextMenuInfo) item.getMenuInfo();  
         int childPosition = ExpandableListView.getPackedPositionChild(info.packedPosition);
         int groupPosition = ExpandableListView.getPackedPositionGroup(info.packedPosition);
-        UploadDbObject uploadFile = (UploadDbObject) mAdapter.getChild(groupPosition, childPosition);
+        OCUpload uploadFile = (OCUpload) mAdapter.getChild(groupPosition, childPosition);
         switch (item.getItemId()) {
         case R.id.action_cancel_upload:
             ((FileActivity) getActivity()).getFileOperationsHelper().cancelTransference(uploadFile.getOCFile());
@@ -185,7 +185,7 @@ public class UploadListFragment extends ExpandableListFragment {
          * @param file
          * @return return true if click was handled.
          */
-        public boolean onUploadItemClick(UploadDbObject file);
+        public boolean onUploadItemClick(OCUpload file);
 
     }
 

src/com/owncloud/android/utils/FileStorageUtils.java

@@ -30,7 +30,6 @@ import third_parties.daveKoeller.AlphanumComparator;
 import com.owncloud.android.MainApp;
 import com.owncloud.android.R;
 import com.owncloud.android.datamodel.OCFile;
-import com.owncloud.android.db.UploadDbObject;
 import com.owncloud.android.lib.resources.files.RemoteFile;
 
 import android.accounts.Account;

src/com/owncloud/android/utils/UploadUtils.java

@@ -27,8 +27,6 @@ import android.net.ConnectivityManager;
 import android.net.NetworkInfo.State;
 import android.os.BatteryManager;
 
-import com.owncloud.android.db.UploadDbObject;
-
 
 public class UploadUtils {