import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import com.owncloud.android.R;
-import com.owncloud.android.authentication.AuthenticatorActivity;
-import com.owncloud.android.datamodel.FileDataStorageManager;
-import com.owncloud.android.datamodel.OCFile;
-import com.owncloud.android.db.DbHandler;
-import com.owncloud.android.operations.CreateFolderOperation;
-import com.owncloud.android.lib.resources.files.RemoteFile;
-import com.owncloud.android.lib.common.operations.RemoteOperation;
-import com.owncloud.android.lib.common.operations.RemoteOperationResult;
-import com.owncloud.android.operations.UploadFileOperation;
-import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode;
-import com.owncloud.android.lib.resources.files.ExistenceCheckRemoteOperation;
-import com.owncloud.android.lib.resources.files.ReadRemoteFileOperation;
-import com.owncloud.android.lib.resources.files.FileUtils;
-import com.owncloud.android.lib.resources.status.OwnCloudVersion;
-import com.owncloud.android.lib.common.accounts.AccountUtils.Constants;
-import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
-import com.owncloud.android.lib.common.OwnCloudClientFactory;
-import com.owncloud.android.lib.common.OwnCloudClient;
-import com.owncloud.android.ui.activity.FailedUploadActivity;
-import com.owncloud.android.ui.activity.FileActivity;
-import com.owncloud.android.ui.activity.FileDisplayActivity;
-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.Log_OC;
-import com.owncloud.android.utils.NotificationBuilderWithProgressBar;
-
import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AccountsException;
import android.support.v4.app.NotificationCompat;
import android.webkit.MimeTypeMap;
+import com.owncloud.android.R;
+import com.owncloud.android.authentication.AccountUtils;
+import com.owncloud.android.authentication.AuthenticatorActivity;
+import com.owncloud.android.datamodel.FileDataStorageManager;
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.db.DbHandler;
+import com.owncloud.android.lib.common.OwnCloudAccount;
+import com.owncloud.android.lib.common.OwnCloudClient;
+import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
+import com.owncloud.android.lib.common.accounts.AccountUtils.Constants;
+import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
+import com.owncloud.android.lib.common.operations.RemoteOperation;
+import com.owncloud.android.lib.common.operations.RemoteOperationResult;
+import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode;
+import com.owncloud.android.lib.common.utils.Log_OC;
+import com.owncloud.android.lib.resources.files.ExistenceCheckRemoteOperation;
+import com.owncloud.android.lib.resources.files.FileUtils;
+import com.owncloud.android.lib.resources.files.ReadRemoteFileOperation;
+import com.owncloud.android.lib.resources.files.RemoteFile;
+import com.owncloud.android.lib.resources.status.OwnCloudVersion;
+import com.owncloud.android.notifications.NotificationBuilderWithProgressBar;
+import com.owncloud.android.notifications.NotificationDelayer;
+import com.owncloud.android.operations.CreateFolderOperation;
+import com.owncloud.android.operations.UploadFileOperation;
+import com.owncloud.android.operations.common.SyncOperation;
+import com.owncloud.android.ui.activity.FileActivity;
+import com.owncloud.android.ui.activity.FileDisplayActivity;
+import com.owncloud.android.utils.ErrorMessageAdapter;
+import com.owncloud.android.utils.UriUtils;
+
public class FileUploader extends Service implements OnDatatransferProgressListener {
private NotificationCompat.Builder mNotificationBuilder;
private int mLastPercent;
+ private static final String MIME_TYPE_PDF = "application/pdf";
+ private static final String FILE_EXTENSION_PDF = ".pdf";
+
public static String getUploadFinishMessage() {
return FileUploader.class.getName().toString() + UPLOAD_FINISH_MESSAGE;
return Service.START_NOT_STICKY;
}
Account account = intent.getParcelableExtra(KEY_ACCOUNT);
+ if (!AccountUtils.exists(account, getApplicationContext())) {
+ return Service.START_NOT_STICKY;
+ }
String[] localPaths = null, remotePaths = null, mimeTypes = null;
OCFile[] files = null;
AccountManager aMgr = AccountManager.get(this);
String version = aMgr.getUserData(account, Constants.KEY_OC_VERSION);
- String versionString = aMgr.getUserData(account, Constants.KEY_OC_VERSION_STRING);
- OwnCloudVersion ocv = new OwnCloudVersion(version, versionString);
+ OwnCloudVersion ocv = new OwnCloudVersion(version);
boolean chunked = FileUploader.chunkedUploadIsSupported(ocv);
AbstractList<String> requestedUploads = new Vector<String>();
/// 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 = OwnCloudClientFactory.createOwnCloudClient(mLastAccount, getApplicationContext());
+ mStorageManager =
+ new FileDataStorageManager(mLastAccount, getContentResolver());
+ OwnCloudAccount ocAccount = new OwnCloudAccount(mLastAccount, this);
+ mUploadClient = OwnCloudClientManagerFactory.getDefaultSingleton().
+ getClientFor(ocAccount, this);
}
/// check the existence of the parent folder for the file to upload
RemoteOperation operation = new ExistenceCheckRemoteOperation(pathToGrant, this, false);
RemoteOperationResult result = operation.execute(mUploadClient);
if (!result.isSuccess() && result.getCode() == ResultCode.FILE_NOT_FOUND && mCurrentUpload.isRemoteFolderToBeCreated()) {
- operation = new CreateFolderOperation( pathToGrant,
- true,
- mStorageManager );
- result = operation.execute(mUploadClient);
+ SyncOperation syncOp = new CreateFolderOperation( pathToGrant, true);
+ result = syncOp.execute(mUploadClient, mStorageManager);
}
if (result.isSuccess()) {
OCFile parentDir = mStorageManager.getFileByPath(pathToGrant);
// coincidence; nothing else is needed, the storagePath is right
// in the instance returned by mCurrentUpload.getFile()
}
-
+ file.setNeedsUpdateThumbnail(true);
mStorageManager.saveFile(file);
}
file.setModificationTimestamp(remoteFile.getModifiedTimestamp());
file.setModificationTimestampAtLastSyncForData(remoteFile.getModifiedTimestamp());
// file.setEtag(remoteFile.getEtag()); // TODO Etag, where available
+ file.setRemoteId(remoteFile.getRemoteId());
}
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
// MIME type
if (mimeType == null || mimeType.length() <= 0) {
if (mimeType == null) {
mimeType = "application/octet-stream";
}
+
+ if (isPdfFileFromContentProviderWithoutExtension(localPath, mimeType)){
+ remotePath += FILE_EXTENSION_PDF;
+ }
+
+ 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
+
+
newFile.setMimetype(mimeType);
return newFile;
* @param uploadResult Result of the upload operation.
* @param upload Finished upload operation
*/
- private void notifyUploadResult(RemoteOperationResult uploadResult, UploadFileOperation upload) {
+ 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
- mNotificationManager.cancel(R.string.uploader_upload_in_progress_ticker);
-
- } else if (uploadResult.isSuccess()) {
- // / success -> silent update of progress notification to success
- // message
- mNotificationBuilder
- .setOngoing(false)
- .setAutoCancel(true)
- .setProgress(0, 0, false);
+ // / cancelled operation or success -> silent removal of progress notification
+ mNotificationManager.cancel(R.string.uploader_upload_in_progress_ticker);
+
+ // Show the result: success or fail notification
+ if (!uploadResult.isCancelled()) {
+ int tickerId = (uploadResult.isSuccess()) ? R.string.uploader_upload_succeeded_ticker :
+ R.string.uploader_upload_failed_ticker;
- /// includes a pending intent in the notification showing the details view of the file
- Intent showDetailsIntent = null;
- if (PreviewImageFragment.canBePreviewed(upload.getFile())) {
- showDetailsIntent = new Intent(this, PreviewImageActivity.class);
- } else {
- showDetailsIntent = new Intent(this, FileDisplayActivity.class);
- }
- showDetailsIntent.putExtra(FileActivity.EXTRA_FILE, upload.getFile());
- showDetailsIntent.putExtra(FileActivity.EXTRA_ACCOUNT, upload.getAccount());
- showDetailsIntent.putExtra(FileActivity.EXTRA_FROM_NOTIFICATION, true);;
- mNotificationBuilder
- .setContentIntent(PendingIntent.getActivity(
- this, (int) System.currentTimeMillis(), showDetailsIntent, 0
- ))
- .setTicker(getString(R.string.uploader_upload_succeeded_ticker))
- .setContentTitle(getString(R.string.uploader_upload_succeeded_ticker))
- .setContentText(
- String.format(getString(R.string.uploader_upload_succeeded_content_single),
- upload.getFileName())
- );
-
- mNotificationManager.notify(R.string.uploader_upload_in_progress_ticker, mNotificationBuilder.build()); // NOT
- // AN
- DbHandler db = new DbHandler(this.getBaseContext());
- db.removeIUPendingFile(mCurrentUpload.getOriginalStoragePath());
- db.close();
+ String content = null;
- } else {
+ // check credentials error
+ boolean needsToUpdateCredentials = (
+ uploadResult.getCode() == ResultCode.UNAUTHORIZED ||
+ uploadResult.isIdPRedirection()
+ );
+ tickerId = (needsToUpdateCredentials) ?
+ R.string.uploader_upload_failed_credentials_error : tickerId;
- // / fail -> explicit failure notification
- mNotificationManager.cancel(R.string.uploader_upload_in_progress_ticker);
- NotificationCompat.Builder errorBuilder = new NotificationCompat.Builder(this);
- errorBuilder
- .setSmallIcon(R.drawable.notification_icon)
- .setTicker(getString(R.string.uploader_upload_failed_ticker))
- .setContentTitle(getString(R.string.uploader_upload_failed_ticker))
- .setAutoCancel(true);
- String content = null;
+ mNotificationBuilder
+ .setTicker(getString(tickerId))
+ .setContentTitle(getString(tickerId))
+ .setAutoCancel(true)
+ .setOngoing(false)
+ .setProgress(0, 0, false);
+
+ content = ErrorMessageAdapter.getErrorCauseMessage(
+ uploadResult, upload, getResources()
+ );
- boolean needsToUpdateCredentials = (uploadResult.getCode() == ResultCode.UNAUTHORIZED ||
- //(uploadResult.isTemporalRedirection() && uploadResult.isIdPRedirection() &&
- (uploadResult.isIdPRedirection() &&
- mUploadClient.getCredentials() == null));
- //MainApp.getAuthTokenTypeSamlSessionCookie().equals(mUploadClient.getAuthTokenType())));
if (needsToUpdateCredentials) {
// 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_ENFORCED_UPDATE, true);
- updateAccountCredentials.putExtra(AuthenticatorActivity.EXTRA_ACTION, AuthenticatorActivity.ACTION_UPDATE_TOKEN);
+ updateAccountCredentials.putExtra(
+ AuthenticatorActivity.EXTRA_ACCOUNT, upload.getAccount()
+ );
+ updateAccountCredentials.putExtra(
+ AuthenticatorActivity.EXTRA_ACTION,
+ AuthenticatorActivity.ACTION_UPDATE_EXPIRED_TOKEN
+ );
updateAccountCredentials.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
updateAccountCredentials.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
updateAccountCredentials.addFlags(Intent.FLAG_FROM_BACKGROUND);
- errorBuilder.setContentIntent(PendingIntent.getActivity(
- this, (int) System.currentTimeMillis(), updateAccountCredentials, PendingIntent.FLAG_ONE_SHOT
+ mNotificationBuilder.setContentIntent(PendingIntent.getActivity(
+ this,
+ (int) System.currentTimeMillis(),
+ updateAccountCredentials,
+ PendingIntent.FLAG_ONE_SHOT
));
- content = String.format(getString(R.string.uploader_upload_failed_content_single), upload.getFileName());
- mUploadClient = null; // grant that future retries on the same account will get the fresh credentials
+
+ mUploadClient = null;
+ // grant that future retries on the same account will get the fresh credentials
} else {
- // TODO put something smart in the contentIntent below
-
- 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);
- }
- errorBuilder
- .setContentIntent(PendingIntent.getActivity(
- this, (int) System.currentTimeMillis(), detailUploadIntent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_ONE_SHOT
- ))
- .setContentText(content);
+ mNotificationBuilder.setContentText(content);
if (upload.isInstant()) {
DbHandler db = null;
try {
db = new DbHandler(this.getBaseContext());
- String message = uploadResult.getLogMessage() + " errorCode: " + uploadResult.getCode();
+ 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 = 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);
+ db.putFileForLater(
+ upload.getOriginalStoragePath(),
+ upload.getAccount().name,
+ message
+ );
}
}
} finally {
}
}
- mNotificationManager.notify(R.string.uploader_upload_failed_ticker, errorBuilder.build());
+ mNotificationBuilder.setContentText(content);
+ mNotificationManager.notify(tickerId, mNotificationBuilder.build());
+
+ if (uploadResult.isSuccess()) {
+
+ DbHandler db = new DbHandler(this.getBaseContext());
+ db.removeIUPendingFile(mCurrentUpload.getOriginalStoragePath());
+ db.close();
+
+ // remove success notification, with a delay of 2 seconds
+ NotificationDelayer.cancelWithDelay(
+ mNotificationManager,
+ R.string.uploader_upload_succeeded_ticker,
+ 2000);
+
+ }
}
-
}
/**
sendStickyBroadcast(end);
}
+ /**
+ * Checks if content provider, using the content:// scheme, returns a file with mime-type
+ * 'application/pdf' but file has not extension
+ * @param localPath
+ * @param mimeType
+ * @return true if is needed to add the pdf file extension to the file
+ */
+ private boolean isPdfFileFromContentProviderWithoutExtension(String localPath, String mimeType) {
+ return localPath.startsWith(UriUtils.URI_CONTENT_SCHEME) &&
+ mimeType.equals(MIME_TYPE_PDF) &&
+ !localPath.endsWith(FILE_EXTENSION_PDF);
+ }
+
}
projects / pub / Android / ownCloud.git / blobdiff