X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/a7cbc53251aac878a9a356166d388685523f26bc..52bd01bcedf1b8f13c49b67ee40a848bae1a9d40:/src/com/owncloud/android/files/services/FileUploader.java diff --git a/src/com/owncloud/android/files/services/FileUploader.java b/src/com/owncloud/android/files/services/FileUploader.java index 958036a7..78660986 100644 --- a/src/com/owncloud/android/files/services/FileUploader.java +++ b/src/com/owncloud/android/files/services/FileUploader.java @@ -1,10 +1,10 @@ /* ownCloud Android client application * Copyright (C) 2012 Bartek Przybylski + * Copyright (C) 2012-2013 ownCloud Inc. * * 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. + * it under the terms of the GNU General Public License version 2, + * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,8 +19,11 @@ package com.owncloud.android.files.services; import java.io.File; +import java.io.IOException; import java.util.AbstractList; +import java.util.HashMap; import java.util.Iterator; +import java.util.Map; import java.util.Vector; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; @@ -29,16 +32,18 @@ import org.apache.http.HttpStatus; import org.apache.jackrabbit.webdav.MultiStatus; import org.apache.jackrabbit.webdav.client.methods.PropFindMethod; -import com.owncloud.android.authenticator.AccountAuthenticator; +import com.owncloud.android.authentication.AccountAuthenticator; +import com.owncloud.android.authentication.AuthenticatorActivity; import com.owncloud.android.datamodel.FileDataStorageManager; import com.owncloud.android.datamodel.OCFile; -import com.owncloud.android.files.InstantUploadBroadcastReceiver; import com.owncloud.android.operations.ChunkedUploadFileOperation; +import com.owncloud.android.operations.CreateFolderOperation; +import com.owncloud.android.operations.RemoteOperation; import com.owncloud.android.operations.RemoteOperationResult; import com.owncloud.android.operations.UploadFileOperation; +import com.owncloud.android.operations.RemoteOperationResult.ResultCode; import com.owncloud.android.ui.activity.FileDetailActivity; import com.owncloud.android.ui.fragment.FileDetailFragment; -import com.owncloud.android.utils.FileStorageUtils; import com.owncloud.android.utils.OwnCloudVersion; import eu.alefzero.webdav.OnDatatransferProgressListener; @@ -49,6 +54,7 @@ import com.owncloud.android.network.OwnCloudClientUtils; import android.accounts.Account; import android.accounts.AccountManager; +import android.accounts.AccountsException; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; @@ -61,11 +67,18 @@ import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.Process; -import android.util.Log; import android.webkit.MimeTypeMap; import android.widget.RemoteViews; +import com.owncloud.android.Log_OC; import com.owncloud.android.R; +import com.owncloud.android.db.DbHandler; +import com.owncloud.android.ui.activity.FailedUploadActivity; +import com.owncloud.android.ui.activity.InstantUploadActivity; +import com.owncloud.android.ui.preview.PreviewImageActivity; +import com.owncloud.android.ui.preview.PreviewImageFragment; +import com.owncloud.android.utils.FileStorageUtils; + import eu.alefzero.webdav.WebdavClient; public class FileUploader extends Service implements OnDatatransferProgressListener { @@ -74,25 +87,30 @@ public class FileUploader extends Service implements OnDatatransferProgressListe public static final String EXTRA_UPLOAD_RESULT = "RESULT"; public static final String EXTRA_REMOTE_PATH = "REMOTE_PATH"; public static final String EXTRA_OLD_REMOTE_PATH = "OLD_REMOTE_PATH"; - public static final String EXTRA_FILE_PATH = "FILE_PATH"; - public static final String ACCOUNT_NAME = "ACCOUNT_NAME"; - + public static final String EXTRA_OLD_FILE_PATH = "OLD_FILE_PATH"; + public static final String ACCOUNT_NAME = "ACCOUNT_NAME"; + public static final String KEY_FILE = "FILE"; public static final String KEY_LOCAL_FILE = "LOCAL_FILE"; public static final String KEY_REMOTE_FILE = "REMOTE_FILE"; public static final String KEY_MIME_TYPE = "MIME_TYPE"; public static final String KEY_ACCOUNT = "ACCOUNT"; - + public static final String KEY_UPLOAD_TYPE = "UPLOAD_TYPE"; public static final String KEY_FORCE_OVERWRITE = "KEY_FORCE_OVERWRITE"; public static final String KEY_INSTANT_UPLOAD = "INSTANT_UPLOAD"; + public static final String KEY_LOCAL_BEHAVIOUR = "BEHAVIOUR"; + + public static final int LOCAL_BEHAVIOUR_COPY = 0; + public static final int LOCAL_BEHAVIOUR_MOVE = 1; + public static final int LOCAL_BEHAVIOUR_FORGET = 2; public static final int UPLOAD_SINGLE_FILE = 0; public static final int UPLOAD_MULTIPLE_FILES = 1; private static final String TAG = FileUploader.class.getSimpleName(); - + private Looper mServiceLooper; private ServiceHandler mServiceHandler; private IBinder mBinder; @@ -102,18 +120,17 @@ public class FileUploader extends Service implements OnDatatransferProgressListe private ConcurrentMap mPendingUploads = new ConcurrentHashMap(); private UploadFileOperation mCurrentUpload = null; - + private NotificationManager mNotificationManager; private Notification mNotification; private int mLastPercent; private RemoteViews mDefaultNotificationContentView; - - + /** * Builds a key for mPendingUploads from the account and file to upload * - * @param account Account where the file to download is stored - * @param file File to download + * @param account Account where the file to upload is stored + * @param file File to upload */ private String buildRemoteName(Account account, OCFile file) { return account.name + file.getRemotePath(); @@ -123,72 +140,77 @@ public class FileUploader extends Service implements OnDatatransferProgressListe return account.name + remotePath; } - /** * Checks if an ownCloud server version should support chunked uploads. * - * @param version OwnCloud version instance corresponding to an ownCloud server. - * @return 'True' if the ownCloud server with version supports chunked uploads. + * @param version OwnCloud version instance corresponding to an ownCloud + * server. + * @return 'True' if the ownCloud server with version supports chunked + * uploads. */ private static boolean chunkedUploadIsSupported(OwnCloudVersion version) { return (version != null && version.compareTo(OwnCloudVersion.owncloud_v4_5) >= 0); } - - /** * Service initialization */ @Override public void onCreate() { super.onCreate(); + Log_OC.i(TAG, "mPendingUploads size:" + mPendingUploads.size()); mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); - HandlerThread thread = new HandlerThread("FileUploaderThread", - Process.THREAD_PRIORITY_BACKGROUND); + HandlerThread thread = new HandlerThread("FileUploaderThread", Process.THREAD_PRIORITY_BACKGROUND); thread.start(); mServiceLooper = thread.getLooper(); mServiceHandler = new ServiceHandler(mServiceLooper, this); mBinder = new FileUploaderBinder(); } - /** * Entry point to add one or several files to the queue of uploads. * - * New uploads are added calling to startService(), resulting in a call to this method. This ensures the service will keep on working - * although the caller activity goes away. + * New uploads are added calling to startService(), resulting in a call to + * this method. This ensures the service will keep on working although the + * caller activity goes away. */ @Override public int onStartCommand(Intent intent, int flags, int startId) { - if (!intent.hasExtra(KEY_ACCOUNT) || !intent.hasExtra(KEY_UPLOAD_TYPE) || !(intent.hasExtra(KEY_LOCAL_FILE) || intent.hasExtra(KEY_FILE))) { - Log.e(TAG, "Not enough information provided in intent"); + if (!intent.hasExtra(KEY_ACCOUNT) || !intent.hasExtra(KEY_UPLOAD_TYPE) + || !(intent.hasExtra(KEY_LOCAL_FILE) || intent.hasExtra(KEY_FILE))) { + Log_OC.e(TAG, "Not enough information provided in intent"); return Service.START_NOT_STICKY; } int uploadType = intent.getIntExtra(KEY_UPLOAD_TYPE, -1); if (uploadType == -1) { - Log.e(TAG, "Incorrect upload type provided"); + Log_OC.e(TAG, "Incorrect upload type provided"); return Service.START_NOT_STICKY; } Account account = intent.getParcelableExtra(KEY_ACCOUNT); - + String[] localPaths = null, remotePaths = null, mimeTypes = null; OCFile[] files = null; if (uploadType == UPLOAD_SINGLE_FILE) { - + if (intent.hasExtra(KEY_FILE)) { - files = new OCFile[] {intent.getParcelableExtra(KEY_FILE) }; - + files = new OCFile[] { intent.getParcelableExtra(KEY_FILE) }; + } else { localPaths = new String[] { intent.getStringExtra(KEY_LOCAL_FILE) }; remotePaths = new String[] { intent.getStringExtra(KEY_REMOTE_FILE) }; mimeTypes = new String[] { intent.getStringExtra(KEY_MIME_TYPE) }; } - + } else { // mUploadType == UPLOAD_MULTIPLE_FILES - + if (intent.hasExtra(KEY_FILE)) { - files = (OCFile[]) intent.getParcelableArrayExtra(KEY_FILE); // TODO will this casting work fine? - + files = (OCFile[]) intent.getParcelableArrayExtra(KEY_FILE); // TODO + // will + // this + // casting + // work + // fine? + } else { localPaths = intent.getStringArrayExtra(KEY_LOCAL_FILE); remotePaths = intent.getStringArrayExtra(KEY_REMOTE_FILE); @@ -197,106 +219,137 @@ public class FileUploader extends Service implements OnDatatransferProgressListe } FileDataStorageManager storageManager = new FileDataStorageManager(account, getContentResolver()); - + boolean forceOverwrite = intent.getBooleanExtra(KEY_FORCE_OVERWRITE, false); - boolean isInstant = intent.getBooleanExtra(KEY_INSTANT_UPLOAD, false); + boolean isInstant = intent.getBooleanExtra(KEY_INSTANT_UPLOAD, false); + int localAction = intent.getIntExtra(KEY_LOCAL_BEHAVIOUR, LOCAL_BEHAVIOUR_COPY); boolean fixed = false; if (isInstant) { - fixed = checkAndFixInstantUploadDirectory(storageManager); // MUST be done BEFORE calling obtainNewOCFileToUpload + fixed = checkAndFixInstantUploadDirectory(storageManager); // MUST + // be + // done + // BEFORE + // calling + // obtainNewOCFileToUpload } - + if (intent.hasExtra(KEY_FILE) && files == null) { - Log.e(TAG, "Incorrect array for OCFiles provided in upload intent"); + Log_OC.e(TAG, "Incorrect array for OCFiles provided in upload intent"); return Service.START_NOT_STICKY; - + } else if (!intent.hasExtra(KEY_FILE)) { if (localPaths == null) { - Log.e(TAG, "Incorrect array for local paths provided in upload intent"); + Log_OC.e(TAG, "Incorrect array for local paths provided in upload intent"); return Service.START_NOT_STICKY; } if (remotePaths == null) { - Log.e(TAG, "Incorrect array for remote paths provided in upload intent"); + Log_OC.e(TAG, "Incorrect array for remote paths provided in upload intent"); return Service.START_NOT_STICKY; } if (localPaths.length != remotePaths.length) { - Log.e(TAG, "Different number of remote paths and local paths!"); + Log_OC.e(TAG, "Different number of remote paths and local paths!"); return Service.START_NOT_STICKY; } - + files = new OCFile[localPaths.length]; - for (int i=0; i < localPaths.length; i++) { - files[i] = obtainNewOCFileToUpload(remotePaths[i], localPaths[i], ((mimeTypes!=null)?mimeTypes[i]:(String)null), storageManager); + for (int i = 0; i < localPaths.length; i++) { + files[i] = obtainNewOCFileToUpload(remotePaths[i], localPaths[i], ((mimeTypes != null) ? mimeTypes[i] + : (String) null), storageManager); + if (files[i] == null) { + // TODO @andomaex add failure Notiification + return Service.START_NOT_STICKY; + } } } - - OwnCloudVersion ocv = new OwnCloudVersion(AccountManager.get(this).getUserData(account, AccountAuthenticator.KEY_OC_VERSION)); + + OwnCloudVersion ocv = new OwnCloudVersion(AccountManager.get(this).getUserData(account, + AccountAuthenticator.KEY_OC_VERSION)); boolean chunked = FileUploader.chunkedUploadIsSupported(ocv); AbstractList requestedUploads = new Vector(); String uploadKey = null; UploadFileOperation newUpload = null; try { - for (int i=0; i < files.length; i++) { + for (int i = 0; i < files.length; i++) { uploadKey = buildRemoteName(account, files[i].getRemotePath()); if (chunked) { - newUpload = new ChunkedUploadFileOperation(account, files[i], isInstant, forceOverwrite); + newUpload = new ChunkedUploadFileOperation(account, files[i], isInstant, forceOverwrite, + localAction); } else { - newUpload = new UploadFileOperation(account, files[i], isInstant, forceOverwrite); + newUpload = new UploadFileOperation(account, files[i], isInstant, forceOverwrite, localAction); } - if (fixed && i==0) { + if (fixed && i == 0) { newUpload.setRemoteFolderToBeCreated(); } mPendingUploads.putIfAbsent(uploadKey, newUpload); newUpload.addDatatransferProgressListener(this); + newUpload.addDatatransferProgressListener((FileUploaderBinder)mBinder); requestedUploads.add(uploadKey); } - + } catch (IllegalArgumentException e) { - Log.e(TAG, "Not enough information provided in intent: " + e.getMessage()); + Log_OC.e(TAG, "Not enough information provided in intent: " + e.getMessage()); return START_NOT_STICKY; - + } catch (IllegalStateException e) { - Log.e(TAG, "Bad information provided in intent: " + e.getMessage()); + Log_OC.e(TAG, "Bad information provided in intent: " + e.getMessage()); return START_NOT_STICKY; - + } catch (Exception e) { - Log.e(TAG, "Unexpected exception while processing upload intent", e); + Log_OC.e(TAG, "Unexpected exception while processing upload intent", e); return START_NOT_STICKY; - + } - + if (requestedUploads.size() > 0) { Message msg = mServiceHandler.obtainMessage(); msg.arg1 = startId; msg.obj = requestedUploads; mServiceHandler.sendMessage(msg); } - + Log_OC.i(TAG, "mPendingUploads size:" + mPendingUploads.size()); return Service.START_NOT_STICKY; } - /** - * Provides a binder object that clients can use to perform operations on the queue of uploads, excepting the addition of new files. + * Provides a binder object that clients can use to perform operations on + * the queue of uploads, excepting the addition of new files. * - * Implemented to perform cancellation, pause and resume of existing uploads. + * Implemented to perform cancellation, pause and resume of existing + * uploads. */ @Override public IBinder onBind(Intent arg0) { return mBinder; } + + /** + * Called when ALL the bound clients were onbound. + */ + @Override + public boolean onUnbind(Intent intent) { + ((FileUploaderBinder)mBinder).clearListeners(); + return false; // not accepting rebinding (default behaviour) + } + /** - * Binder to let client components to perform operations on the queue of uploads. + * Binder to let client components to perform operations on the queue of + * uploads. * - * It provides by itself the available operations. + * It provides by itself the available operations. */ - public class FileUploaderBinder extends Binder { + public class FileUploaderBinder extends Binder implements OnDatatransferProgressListener { + + /** + * Map of listeners that will be reported about progress of uploads from a {@link FileUploaderBinder} instance + */ + private Map mBoundListeners = new HashMap(); /** * Cancels a pending or current upload of a remote file. * - * @param account Owncloud account where the remote file will be stored. - * @param file A file in the queue of pending uploads + * @param account Owncloud account where the remote file will be stored. + * @param file A file in the queue of pending uploads */ public void cancel(Account account, OCFile file) { UploadFileOperation upload = null; @@ -309,19 +362,30 @@ public class FileUploader extends Service implements OnDatatransferProgressListe } + + public void clearListeners() { + mBoundListeners.clear(); + } + + + + /** - * Returns True when the file described by 'file' is being uploaded to the ownCloud account 'account' or waiting for it + * Returns True when the file described by 'file' is being uploaded to + * the ownCloud account 'account' or waiting for it * - * If 'file' is a directory, returns 'true' if some of its descendant files is downloading or waiting to download. + * If 'file' is a directory, returns 'true' if some of its descendant files is uploading or waiting to upload. * - * @param account Owncloud account where the remote file will be stored. - * @param file A file that could be in the queue of pending uploads + * @param account Owncloud account where the remote file will be stored. + * @param file A file that could be in the queue of pending uploads */ public boolean isUploading(Account account, OCFile file) { + if (account == null || file == null) + return false; String targetKey = buildRemoteName(account, file); synchronized (mPendingUploads) { if (file.isDirectory()) { - // this can be slow if there are many downloads :( + // this can be slow if there are many uploads :( Iterator it = mPendingUploads.keySet().iterator(); boolean found = false; while (it.hasNext() && !found) { @@ -333,19 +397,69 @@ public class FileUploader extends Service implements OnDatatransferProgressListe } } } + + + /** + * Adds a listener interested in the progress of the upload for a concrete file. + * + * @param listener Object to notify about progress of transfer. + * @param account ownCloud account holding the file of interest. + * @param file {@link OCfile} of interest for listener. + */ + public void addDatatransferProgressListener (OnDatatransferProgressListener listener, Account account, OCFile file) { + if (account == null || file == null || listener == null) return; + String targetKey = buildRemoteName(account, file); + mBoundListeners.put(targetKey, listener); + } + + + + /** + * Removes a listener interested in the progress of the upload for a concrete file. + * + * @param listener Object to notify about progress of transfer. + * @param account ownCloud account holding the file of interest. + * @param file {@link OCfile} of interest for listener. + */ + public void removeDatatransferProgressListener (OnDatatransferProgressListener listener, Account account, OCFile file) { + if (account == null || file == null || listener == null) return; + String targetKey = buildRemoteName(account, file); + if (mBoundListeners.get(targetKey) == listener) { + mBoundListeners.remove(targetKey); + } + } + + + @Override + public void onTransferProgress(long progressRate) { + // old way, should not be in use any more + } + + + @Override + public void onTransferProgress(long progressRate, long totalTransferredSoFar, long totalToTransfer, + String fileName) { + String key = buildRemoteName(mCurrentUpload.getAccount(), mCurrentUpload.getFile()); + OnDatatransferProgressListener boundListener = mBoundListeners.get(key); + if (boundListener != null) { + boundListener.onTransferProgress(progressRate, totalTransferredSoFar, totalToTransfer, fileName); + } + } + } - - - - - /** - * Upload worker. Performs the pending uploads in the order they were requested. + + /** + * Upload worker. Performs the pending uploads in the order they were + * requested. * - * Created with the Looper of a new thread, started in {@link FileUploader#onCreate()}. + * Created with the Looper of a new thread, started in + * {@link FileUploader#onCreate()}. */ private static class ServiceHandler extends Handler { - // don't make it a final class, and don't remove the static ; lint will warn about a possible memory leak + // don't make it a final class, and don't remove the static ; lint will + // warn about a possible memory leak FileUploader mService; + public ServiceHandler(Looper looper, FileUploader service) { super(looper); if (service == null) @@ -367,66 +481,77 @@ public class FileUploader extends Service implements OnDatatransferProgressListe } } - - - /** * Core upload method: sends the file(s) to upload * - * @param uploadKey Key to access the upload to perform, contained in mPendingUploads + * @param uploadKey Key to access the upload to perform, contained in + * mPendingUploads */ public void uploadFile(String uploadKey) { - synchronized(mPendingUploads) { + synchronized (mPendingUploads) { mCurrentUpload = mPendingUploads.get(uploadKey); } - + if (mCurrentUpload != null) { - + notifyUploadStart(mCurrentUpload); + RemoteOperationResult uploadResult = null; - /// prepare client object to send requests to the ownCloud server - if (mUploadClient == null || !mLastAccount.equals(mCurrentUpload.getAccount())) { - mLastAccount = mCurrentUpload.getAccount(); - mStorageManager = new FileDataStorageManager(mLastAccount, getContentResolver()); - mUploadClient = OwnCloudClientUtils.createOwnCloudClient(mLastAccount, getApplicationContext()); - } + try { + /// prepare client object to send requests to the ownCloud server + if (mUploadClient == null || !mLastAccount.equals(mCurrentUpload.getAccount())) { + mLastAccount = mCurrentUpload.getAccount(); + mStorageManager = new FileDataStorageManager(mLastAccount, getContentResolver()); + mUploadClient = OwnCloudClientUtils.createOwnCloudClient(mLastAccount, getApplicationContext()); + } - /// create remote folder for instant uploads - if (mCurrentUpload.isRemoteFolderToBeCreated()) { - mUploadClient.createDirectory(InstantUploadBroadcastReceiver.INSTANT_UPLOAD_DIR); // ignoring result; fail could just mean that it already exists, but local database is not synchronized; the upload will be tried anyway - } + /// create remote folder for instant uploads + if (mCurrentUpload.isRemoteFolderToBeCreated()) { + RemoteOperation operation = new CreateFolderOperation( FileStorageUtils.getInstantUploadFilePath(this, ""), + mStorageManager.getFileByPath(OCFile.PATH_SEPARATOR).getFileId(), // TODO generalize this : INSTANT_UPLOAD_DIR could not be a child of root + mStorageManager); + operation.execute(mUploadClient); // ignoring result; fail could just mean that it already exists, but local database is not synchronized; the upload will be tried anyway + } - /// perform the upload - RemoteOperationResult uploadResult = null; - try { + /// perform the upload uploadResult = mCurrentUpload.execute(mUploadClient); if (uploadResult.isSuccess()) { saveUploadedFile(); } + } catch (AccountsException e) { + Log_OC.e(TAG, "Error while trying to get autorization for " + mLastAccount.name, e); + uploadResult = new RemoteOperationResult(e); + + } catch (IOException e) { + Log_OC.e(TAG, "Error while trying to get autorization for " + mLastAccount.name, e); + uploadResult = new RemoteOperationResult(e); + } finally { - synchronized(mPendingUploads) { + synchronized (mPendingUploads) { mPendingUploads.remove(uploadKey); + Log_OC.i(TAG, "Remove CurrentUploadItem from pending upload Item Map."); } } - + /// notify result - notifyUploadResult(uploadResult, mCurrentUpload); + notifyUploadResult(uploadResult, mCurrentUpload); sendFinalBroadcast(mCurrentUpload, uploadResult); - + } - + } /** * Saves a OC File after a successful upload. * - * A PROPFIND is necessary to keep the props in the local database synchronized with the server, - * specially the modification time and Etag (where available) + * A PROPFIND is necessary to keep the props in the local database + * synchronized with the server, specially the modification time and Etag + * (where available) * * TODO refactor this ugly thing */ @@ -434,169 +559,168 @@ public class FileUploader extends Service implements OnDatatransferProgressListe OCFile file = mCurrentUpload.getFile(); long syncDate = System.currentTimeMillis(); file.setLastSyncDateForData(syncDate); - - /// new PROPFIND to keep data consistent with server in theory, should return the same we already have + + // / new PROPFIND to keep data consistent with server in theory, should + // return the same we already have PropFindMethod propfind = null; RemoteOperationResult result = null; try { - propfind = new PropFindMethod(mUploadClient.getBaseUri() + WebdavUtils.encodePath(mCurrentUpload.getRemotePath())); - int status = mUploadClient.executeMethod(propfind); - boolean isMultiStatus = (status == HttpStatus.SC_MULTI_STATUS); - if (isMultiStatus) { - MultiStatus resp = propfind.getResponseBodyAsMultiStatus(); - WebdavEntry we = new WebdavEntry(resp.getResponses()[0], - mUploadClient.getBaseUri().getPath()); - updateOCFile(file, we); - file.setLastSyncDateForProperties(syncDate); - - } else { - mUploadClient.exhaustResponse(propfind.getResponseBodyAsStream()); - } - - result = new RemoteOperationResult(isMultiStatus, status); - Log.i(TAG, "Update: synchronizing properties for uploaded " + mCurrentUpload.getRemotePath() + ": " + result.getLogMessage()); - + propfind = new PropFindMethod(mUploadClient.getBaseUri() + + WebdavUtils.encodePath(mCurrentUpload.getRemotePath())); + int status = mUploadClient.executeMethod(propfind); + boolean isMultiStatus = (status == HttpStatus.SC_MULTI_STATUS); + if (isMultiStatus) { + MultiStatus resp = propfind.getResponseBodyAsMultiStatus(); + WebdavEntry we = new WebdavEntry(resp.getResponses()[0], mUploadClient.getBaseUri().getPath()); + updateOCFile(file, we); + file.setLastSyncDateForProperties(syncDate); + + } else { + mUploadClient.exhaustResponse(propfind.getResponseBodyAsStream()); + } + + result = new RemoteOperationResult(isMultiStatus, status); + Log_OC.i(TAG, "Update: synchronizing properties for uploaded " + mCurrentUpload.getRemotePath() + ": " + + result.getLogMessage()); + } catch (Exception e) { result = new RemoteOperationResult(e); - Log.i(TAG, "Update: synchronizing properties for uploaded " + mCurrentUpload.getRemotePath() + ": " + result.getLogMessage(), e); + Log_OC.e(TAG, "Update: synchronizing properties for uploaded " + mCurrentUpload.getRemotePath() + ": " + + result.getLogMessage(), e); } finally { if (propfind != null) propfind.releaseConnection(); } - + // / maybe this would be better as part of UploadFileOperation... or + // maybe all this method if (mCurrentUpload.wasRenamed()) { OCFile oldFile = mCurrentUpload.getOldFile(); - if (!oldFile.fileExists()) { - // just a name coincidence - file.setStoragePath(oldFile.getStoragePath()); - - } else { - // conflict resolved with 'Keep both' by the user - File localFile = new File(oldFile.getStoragePath()); - File newLocalFile = new File(FileStorageUtils.getDefaultSavePathFor(mCurrentUpload.getAccount().name, file)); - boolean renameSuccessed = localFile.renameTo(newLocalFile); - if (renameSuccessed) { - file.setStoragePath(newLocalFile.getAbsolutePath()); - - } else { - // poor solution - Log.d(TAG, "DAMN IT: local rename failed after uploading a file with a new name already existing both in the remote account and the local database (should be due to a conflict solved with 'keep both'"); - file.setStoragePath(null); - // not so fine: - // - local file will be kept there as 'trash' until is download (and overwritten) again from the server; - // - user will see as 'not down' a file that was just upload - // BUT: - // - no loss of data happened - // - when the user downloads again the renamed and original file from the server, local file names and contents will be correctly synchronized with names and contents in server - } + if (oldFile.fileExists()) { oldFile.setStoragePath(null); mStorageManager.saveFile(oldFile); - } + + } // else: it was just an automatic renaming due to a name + // coincidence; nothing else is needed, the storagePath is right + // in the instance returned by mCurrentUpload.getFile() } - + mStorageManager.saveFile(file); } - private void updateOCFile(OCFile file, WebdavEntry we) { file.setCreationTimestamp(we.createTimestamp()); file.setFileLength(we.contentLength()); file.setMimetype(we.contentType()); - file.setModificationTimestamp(we.modifiedTimesamp()); - // file.setEtag(mCurrentDownload.getEtag()); // TODO Etag, where available + file.setModificationTimestamp(we.modifiedTimestamp()); + file.setModificationTimestampAtLastSyncForData(we.modifiedTimestamp()); + // file.setEtag(mCurrentUpload.getEtag()); // TODO Etag, where available } - - + private boolean checkAndFixInstantUploadDirectory(FileDataStorageManager storageManager) { - OCFile instantUploadDir = storageManager.getFileByPath(InstantUploadBroadcastReceiver.INSTANT_UPLOAD_DIR); + String instantUploadDirPath = FileStorageUtils.getInstantUploadFilePath(this, ""); + OCFile instantUploadDir = storageManager.getFileByPath(instantUploadDirPath); if (instantUploadDir == null) { - // first instant upload in the account, or never account not synchronized after the remote InstantUpload folder was created - OCFile newDir = new OCFile(InstantUploadBroadcastReceiver.INSTANT_UPLOAD_DIR); + // first instant upload in the account. never account not + // synchronized after the remote InstantUpload folder was created + OCFile newDir = new OCFile(instantUploadDirPath); newDir.setMimetype("DIR"); - newDir.setParentId(storageManager.getFileByPath(OCFile.PATH_SEPARATOR).getFileId()); - storageManager.saveFile(newDir); - return true; + OCFile path = storageManager.getFileByPath(OCFile.PATH_SEPARATOR); + + if (path != null) { + newDir.setParentId(path.getFileId()); + storageManager.saveFile(newDir); + return true; + } else { // this should not happen anymore + return false; + } + } return false; } - - private OCFile obtainNewOCFileToUpload(String remotePath, String localPath, String mimeType, FileDataStorageManager storageManager) { + private OCFile obtainNewOCFileToUpload(String remotePath, String localPath, String mimeType, + FileDataStorageManager storageManager) { OCFile newFile = new OCFile(remotePath); newFile.setStoragePath(localPath); newFile.setLastSyncDateForProperties(0); newFile.setLastSyncDateForData(0); - + // size if (localPath != null && localPath.length() > 0) { File localFile = new File(localPath); newFile.setFileLength(localFile.length()); newFile.setLastSyncDateForData(localFile.lastModified()); - } // don't worry about not assigning size, the problems with localPath are checked when the UploadFileOperation instance is created - + } // don't worry about not assigning size, the problems with localPath + // are checked when the UploadFileOperation instance is created + // MIME type if (mimeType == null || mimeType.length() <= 0) { try { - mimeType = MimeTypeMap.getSingleton() - .getMimeTypeFromExtension( - remotePath.substring(remotePath.lastIndexOf('.') + 1)); + mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension( + remotePath.substring(remotePath.lastIndexOf('.') + 1)); } catch (IndexOutOfBoundsException e) { - Log.e(TAG, "Trying to find out MIME type of a file without extension: " + remotePath); + Log_OC.e(TAG, "Trying to find out MIME type of a file without extension: " + remotePath); } } if (mimeType == null) { mimeType = "application/octet-stream"; } newFile.setMimetype(mimeType); - + // parent dir String parentPath = new File(remotePath).getParent(); - parentPath = parentPath.endsWith(OCFile.PATH_SEPARATOR) ? parentPath : parentPath + OCFile.PATH_SEPARATOR ; + parentPath = parentPath.endsWith(OCFile.PATH_SEPARATOR) ? parentPath : parentPath + OCFile.PATH_SEPARATOR; OCFile parentDir = storageManager.getFileByPath(parentPath); - if (parentDir == null) { - throw new IllegalStateException("Can not upload a file to a non existing remote location: " + parentPath); - } long parentDirId = parentDir.getFileId(); newFile.setParentId(parentDirId); return newFile; } - /** * Creates a status notification to show the upload progress * - * @param upload Upload operation starting. + * @param upload Upload operation starting. */ + @SuppressWarnings("deprecation") private void notifyUploadStart(UploadFileOperation upload) { - /// create status notification with a progress bar + // / create status notification with a progress bar mLastPercent = 0; - mNotification = new Notification(R.drawable.icon, getString(R.string.uploader_upload_in_progress_ticker), System.currentTimeMillis()); + mNotification = new Notification(R.drawable.icon, getString(R.string.uploader_upload_in_progress_ticker), + System.currentTimeMillis()); mNotification.flags |= Notification.FLAG_ONGOING_EVENT; mDefaultNotificationContentView = mNotification.contentView; - mNotification.contentView = new RemoteViews(getApplicationContext().getPackageName(), R.layout.progressbar_layout); + mNotification.contentView = new RemoteViews(getApplicationContext().getPackageName(), + R.layout.progressbar_layout); mNotification.contentView.setProgressBar(R.id.status_progress, 100, 0, false); - mNotification.contentView.setTextViewText(R.id.status_text, String.format(getString(R.string.uploader_upload_in_progress_content), 0, new File(upload.getStoragePath()).getName())); + mNotification.contentView.setTextViewText(R.id.status_text, + String.format(getString(R.string.uploader_upload_in_progress_content), 0, upload.getFileName())); mNotification.contentView.setImageViewResource(R.id.status_icon, R.drawable.icon); /// includes a pending intent in the notification showing the details view of the file - Intent showDetailsIntent = new Intent(this, FileDetailActivity.class); + Intent showDetailsIntent = null; + if (PreviewImageFragment.canBePreviewed(upload.getFile())) { + showDetailsIntent = new Intent(this, PreviewImageActivity.class); + } else { + showDetailsIntent = new Intent(this, FileDetailActivity.class); + showDetailsIntent.putExtra(FileDetailActivity.EXTRA_MODE, FileDetailActivity.MODE_DETAILS); + } showDetailsIntent.putExtra(FileDetailFragment.EXTRA_FILE, upload.getFile()); showDetailsIntent.putExtra(FileDetailFragment.EXTRA_ACCOUNT, upload.getAccount()); showDetailsIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); - mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), (int)System.currentTimeMillis(), showDetailsIntent, 0); - + mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), + (int) System.currentTimeMillis(), showDetailsIntent, 0); + mNotificationManager.notify(R.string.uploader_upload_in_progress_ticker, mNotification); } - /** * Callback method to update the progress bar in the status notification */ @Override public void onTransferProgress(long progressRate, long totalTransferredSoFar, long totalToTransfer, String fileName) { - int percent = (int)(100.0*((double)totalTransferredSoFar)/((double)totalToTransfer)); + int percent = (int) (100.0 * ((double) totalTransferredSoFar) / ((double) totalToTransfer)); if (percent != mLastPercent) { mNotification.contentView.setProgressBar(R.id.status_progress, 100, percent, false); String text = String.format(getString(R.string.uploader_upload_in_progress_content), percent, fileName); @@ -605,97 +729,161 @@ public class FileUploader extends Service implements OnDatatransferProgressListe } mLastPercent = percent; } - - + /** - * Callback method to update the progress bar in the status notification (old version) + * Callback method to update the progress bar in the status notification + * (old version) */ @Override public void onTransferProgress(long progressRate) { // NOTHING TO DO HERE ANYMORE } - /** * Updates the status notification with the result of an upload operation. * - * @param uploadResult Result of the upload operation. - * @param upload Finished upload operation + * @param uploadResult Result of the upload operation. + * @param upload Finished upload operation */ private void notifyUploadResult(RemoteOperationResult uploadResult, UploadFileOperation upload) { + Log_OC.d(TAG, "NotifyUploadResult with resultCode: " + uploadResult.getCode()); if (uploadResult.isCancelled()) { - /// cancelled operation -> silent removal of progress notification + // / cancelled operation -> silent removal of progress notification mNotificationManager.cancel(R.string.uploader_upload_in_progress_ticker); - + } else if (uploadResult.isSuccess()) { - /// success -> silent update of progress notification to success message - mNotification.flags ^= Notification.FLAG_ONGOING_EVENT; // remove the ongoing flag + // / success -> silent update of progress notification to success + // message + mNotification.flags ^= Notification.FLAG_ONGOING_EVENT; // remove + // the + // ongoing + // flag mNotification.flags |= Notification.FLAG_AUTO_CANCEL; mNotification.contentView = mDefaultNotificationContentView; /// includes a pending intent in the notification showing the details view of the file - Intent showDetailsIntent = new Intent(this, FileDetailActivity.class); + Intent showDetailsIntent = null; + if (PreviewImageFragment.canBePreviewed(upload.getFile())) { + showDetailsIntent = new Intent(this, PreviewImageActivity.class); + } else { + showDetailsIntent = new Intent(this, FileDetailActivity.class); + showDetailsIntent.putExtra(FileDetailActivity.EXTRA_MODE, FileDetailActivity.MODE_DETAILS); + } showDetailsIntent.putExtra(FileDetailFragment.EXTRA_FILE, upload.getFile()); showDetailsIntent.putExtra(FileDetailFragment.EXTRA_ACCOUNT, upload.getAccount()); showDetailsIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); - mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), (int)System.currentTimeMillis(), showDetailsIntent, 0); - - mNotification.setLatestEventInfo( getApplicationContext(), - getString(R.string.uploader_upload_succeeded_ticker), - String.format(getString(R.string.uploader_upload_succeeded_content_single), (new File(upload.getStoragePath())).getName()), - mNotification.contentIntent); - - mNotificationManager.notify(R.string.uploader_upload_in_progress_ticker, mNotification); // NOT AN ERROR; uploader_upload_in_progress_ticker is the target, not a new notification - - /* Notification about multiple uploads: pending of update - mNotification.setLatestEventInfo( getApplicationContext(), - getString(R.string.uploader_upload_succeeded_ticker), - String.format(getString(R.string.uploader_upload_succeeded_content_multiple), mSuccessCounter), - mNotification.contentIntent); - */ - + mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), + (int) System.currentTimeMillis(), showDetailsIntent, 0); + + mNotification.setLatestEventInfo(getApplicationContext(), + getString(R.string.uploader_upload_succeeded_ticker), + String.format(getString(R.string.uploader_upload_succeeded_content_single), upload.getFileName()), + mNotification.contentIntent); + + mNotificationManager.notify(R.string.uploader_upload_in_progress_ticker, mNotification); // NOT + // AN + DbHandler db = new DbHandler(this.getBaseContext()); + db.removeIUPendingFile(mCurrentUpload.getFile().getStoragePath()); + db.close(); + } else { - /// fail -> explicit failure notification + + // / fail -> explicit failure notification mNotificationManager.cancel(R.string.uploader_upload_in_progress_ticker); - Notification finalNotification = new Notification(R.drawable.icon, getString(R.string.uploader_upload_failed_ticker), System.currentTimeMillis()); + Notification finalNotification = new Notification(R.drawable.icon, + getString(R.string.uploader_upload_failed_ticker), System.currentTimeMillis()); finalNotification.flags |= Notification.FLAG_AUTO_CANCEL; - // TODO put something smart in the contentIntent below - finalNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), (int)System.currentTimeMillis(), new Intent(), 0); - finalNotification.setLatestEventInfo( getApplicationContext(), - getString(R.string.uploader_upload_failed_ticker), - String.format(getString(R.string.uploader_upload_failed_content_single), (new File(upload.getStoragePath())).getName()), - finalNotification.contentIntent); + if (uploadResult.getCode() == ResultCode.UNAUTHORIZED) { + // let the user update credentials with one click + Intent updateAccountCredentials = new Intent(this, AuthenticatorActivity.class); + updateAccountCredentials.putExtra(AuthenticatorActivity.EXTRA_ACCOUNT, upload.getAccount()); + updateAccountCredentials.putExtra(AuthenticatorActivity.EXTRA_ACTION, AuthenticatorActivity.ACTION_UPDATE_TOKEN); + updateAccountCredentials.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + updateAccountCredentials.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); + updateAccountCredentials.addFlags(Intent.FLAG_FROM_BACKGROUND); + finalNotification.contentIntent = PendingIntent.getActivity(this, (int)System.currentTimeMillis(), updateAccountCredentials, PendingIntent.FLAG_ONE_SHOT); + mUploadClient = null; // grant that future retries on the same account will get the fresh credentials + } else { + // TODO put something smart in the contentIntent below + finalNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), (int)System.currentTimeMillis(), new Intent(), 0); + } + String content = null; + if (uploadResult.getCode() == ResultCode.LOCAL_STORAGE_FULL + || uploadResult.getCode() == ResultCode.LOCAL_STORAGE_NOT_COPIED) { + // TODO we need a class to provide error messages for the users + // from a RemoteOperationResult and a RemoteOperation + content = String.format(getString(R.string.error__upload__local_file_not_copied), upload.getFileName(), + getString(R.string.app_name)); + } else if (uploadResult.getCode() == ResultCode.QUOTA_EXCEEDED) { + content = getString(R.string.failed_upload_quota_exceeded_text); + } else { + content = String + .format(getString(R.string.uploader_upload_failed_content_single), upload.getFileName()); + } + + // we add only for instant-uploads the InstantUploadActivity and the + // db entry + Intent detailUploadIntent = null; + if (upload.isInstant() && InstantUploadActivity.IS_ENABLED) { + detailUploadIntent = new Intent(this, InstantUploadActivity.class); + detailUploadIntent.putExtra(FileUploader.KEY_ACCOUNT, upload.getAccount()); + } else { + detailUploadIntent = new Intent(this, FailedUploadActivity.class); + detailUploadIntent.putExtra(FailedUploadActivity.MESSAGE, content); + } + finalNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(), + (int) System.currentTimeMillis(), detailUploadIntent, PendingIntent.FLAG_UPDATE_CURRENT + | PendingIntent.FLAG_ONE_SHOT); + + if (upload.isInstant()) { + DbHandler db = null; + try { + db = new DbHandler(this.getBaseContext()); + String message = uploadResult.getLogMessage() + " errorCode: " + uploadResult.getCode(); + Log_OC.e(TAG, message + " Http-Code: " + uploadResult.getHttpCode()); + if (uploadResult.getCode() == ResultCode.QUOTA_EXCEEDED) { + message = getString(R.string.failed_upload_quota_exceeded_text); + } + if (db.updateFileState(upload.getOriginalStoragePath(), DbHandler.UPLOAD_STATUS_UPLOAD_FAILED, + message) == 0) { + db.putFileForLater(upload.getOriginalStoragePath(), upload.getAccount().name, message); + } + } finally { + if (db != null) { + db.close(); + } + } + } + finalNotification.setLatestEventInfo(getApplicationContext(), + getString(R.string.uploader_upload_failed_ticker), content, finalNotification.contentIntent); + mNotificationManager.notify(R.string.uploader_upload_failed_ticker, finalNotification); - - /* Notification about multiple uploads failure: pending of update - finalNotification.setLatestEventInfo( getApplicationContext(), - getString(R.string.uploader_upload_failed_ticker), - String.format(getString(R.string.uploader_upload_failed_content_multiple), mSuccessCounter, mTotalFilesToSend), - finalNotification.contentIntent); - } */ } - + } - - + /** - * Sends a broadcast in order to the interested activities can update their view + * Sends a broadcast in order to the interested activities can update their + * view * - * @param upload Finished upload operation - * @param uploadResult Result of the upload operation + * @param upload Finished upload operation + * @param uploadResult Result of the upload operation */ private void sendFinalBroadcast(UploadFileOperation upload, RemoteOperationResult uploadResult) { Intent end = new Intent(UPLOAD_FINISH_MESSAGE); - end.putExtra(EXTRA_REMOTE_PATH, upload.getRemotePath()); // real remote path, after possible automatic renaming + end.putExtra(EXTRA_REMOTE_PATH, upload.getRemotePath()); // real remote + // path, after + // possible + // automatic + // renaming if (upload.wasRenamed()) { end.putExtra(EXTRA_OLD_REMOTE_PATH, upload.getOldFile().getRemotePath()); } - end.putExtra(EXTRA_FILE_PATH, upload.getStoragePath()); + end.putExtra(EXTRA_OLD_FILE_PATH, upload.getOriginalStoragePath()); end.putExtra(ACCOUNT_NAME, upload.getAccount().name); end.putExtra(EXTRA_UPLOAD_RESULT, uploadResult.isSuccess()); sendStickyBroadcast(end); } - }