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;
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;
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;
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);
+ }
+
}
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
+import android.accounts.Account;
+import android.content.Context;
+import android.net.Uri;
+
+import com.owncloud.android.MainApp;
import com.owncloud.android.datamodel.OCFile;
import com.owncloud.android.files.services.FileUploader;
-import com.owncloud.android.lib.common.network.ProgressiveDataTransferer;
-import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
import com.owncloud.android.lib.common.OwnCloudClient;
+import com.owncloud.android.lib.common.network.OnDatatransferProgressListener;
+import com.owncloud.android.lib.common.network.ProgressiveDataTransferer;
import com.owncloud.android.lib.common.operations.OperationCancelledException;
import com.owncloud.android.lib.common.operations.RemoteOperation;
import com.owncloud.android.lib.common.operations.RemoteOperationResult;
import com.owncloud.android.lib.resources.files.ExistenceCheckRemoteOperation;
import com.owncloud.android.lib.resources.files.UploadRemoteFileOperation;
import com.owncloud.android.utils.FileStorageUtils;
-
-import android.accounts.Account;
-import android.content.Context;
+import com.owncloud.android.utils.UriUtils;
/**
throw new IllegalArgumentException("Illegal NULL account in UploadFileOperation creation");
if (file == null)
throw new IllegalArgumentException("Illegal NULL file in UploadFileOperation creation");
- if (file.getStoragePath() == null || file.getStoragePath().length() <= 0
- || !(new File(file.getStoragePath()).exists())) {
+ if (file.getStoragePath() == null || file.getStoragePath().length() <= 0) {
throw new IllegalArgumentException(
- "Illegal file in UploadFileOperation; storage path invalid or file not found: "
+ "Illegal file in UploadFileOperation; storage path invalid: "
+ file.getStoragePath());
}
// copied
} else {
+
String temporalPath = FileStorageUtils.getTemporalPath(mAccount.name) + mFile.getRemotePath();
mFile.setStoragePath(temporalPath);
temporalFile = new File(temporalPath);
- if (!mOriginalStoragePath.equals(temporalPath)) { // preventing
- // weird
- // but
- // possible
- // situation
- InputStream in = null;
- OutputStream out = null;
- try {
- File temporalParent = temporalFile.getParentFile();
- temporalParent.mkdirs();
- if (!temporalParent.isDirectory()) {
- throw new IOException("Unexpected error: parent directory could not be created");
- }
- temporalFile.createNewFile();
- if (!temporalFile.isFile()) {
- throw new IOException("Unexpected error: target file could not be created");
- }
- in = new FileInputStream(originalFile);
+
+ File temporalParent = temporalFile.getParentFile();
+ temporalParent.mkdirs();
+ if (!temporalParent.isDirectory()) {
+ throw new IOException("Unexpected error: parent directory could not be created");
+ }
+ temporalFile.createNewFile();
+ if (!temporalFile.isFile()) {
+ throw new IOException("Unexpected error: target file could not be created");
+ }
+
+ InputStream in = null;
+ OutputStream out = null;
+
+ try {
+
+ // In case document provider schema as 'content://'
+ if (mOriginalStoragePath.startsWith(UriUtils.URI_CONTENT_SCHEME)) {
+
+ Uri uri = Uri.parse(mOriginalStoragePath);
+
+ in = MainApp.getAppContext().getContentResolver().openInputStream(uri);
out = new FileOutputStream(temporalFile);
- byte[] buf = new byte[1024];
- int len;
- while ((len = in.read(buf)) > 0) {
- out.write(buf, 0, len);
- }
- } catch (Exception e) {
- result = new RemoteOperationResult(ResultCode.LOCAL_STORAGE_NOT_COPIED);
- return result;
-
- } finally {
- try {
- if (in != null)
- in.close();
- } catch (Exception e) {
- Log_OC.d(TAG, "Weird exception while closing input stream for " + mOriginalStoragePath + " (ignoring)", e);
+ int nRead;
+ byte[] data = new byte[16384];
+
+ while ((nRead = in.read(data, 0, data.length)) != -1) {
+ out.write(data, 0, nRead);
}
- try {
- if (out != null)
- out.close();
- } catch (Exception e) {
- Log_OC.d(TAG, "Weird exception while closing output stream for " + expectedPath + " (ignoring)", e);
+
+ out.flush();
+
+ } else {
+ if (!mOriginalStoragePath.equals(temporalPath)) { // preventing
+ // weird
+ // but
+ // possible
+ // situation
+
+ in = new FileInputStream(originalFile);
+ out = new FileOutputStream(temporalFile);
+ byte[] buf = new byte[1024];
+ int len;
+ while ((len = in.read(buf)) > 0) {
+ out.write(buf, 0, len);
+ }
}
}
+
+ } catch (Exception e) {
+ result = new RemoteOperationResult(ResultCode.LOCAL_STORAGE_NOT_COPIED);
+ return result;
+
+ } finally {
+ try {
+ if (in != null)
+ in.close();
+ } catch (Exception e) {
+ Log_OC.d(TAG, "Weird exception while closing input stream for " + mOriginalStoragePath + " (ignoring)", e);
+ }
+ try {
+ if (out != null)
+ out.close();
+ } catch (Exception e) {
+ Log_OC.d(TAG, "Weird exception while closing output stream for " + expectedPath + " (ignoring)", e);
+ }
}
}
}
public void cancel() {
mUploadOperation.cancel();
}
-
}
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentResolver;
+import android.content.ContentUris;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.res.Resources.NotFoundException;
import android.database.Cursor;
import android.net.Uri;
+import android.os.Build;
import android.os.Bundle;
+import android.os.Environment;
import android.os.IBinder;
import android.preference.PreferenceManager;
+import android.provider.DocumentsContract;
import android.provider.MediaStore;
+import android.provider.OpenableColumns;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
+import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import com.owncloud.android.ui.preview.PreviewVideoActivity;
import com.owncloud.android.utils.DisplayUtils;
import com.owncloud.android.utils.ErrorMessageAdapter;
+import com.owncloud.android.utils.UriUtils;
/**
private String DIALOG_UNTRUSTED_CERT;
private OCFile mWaitingToSend;
-
+
@Override
protected void onCreate(Bundle savedInstanceState) {
Log_OC.d(TAG, "onCreate() start");
private void requestSimpleUpload(Intent data, int resultCode) {
String filepath = null;
+ String mimeType = null;
+
+ Uri selectedImageUri = data.getData();
+
try {
- Uri selectedImageUri = data.getData();
+ mimeType = getContentResolver().getType(selectedImageUri);
String filemanagerstring = selectedImageUri.getPath();
String selectedImagePath = getPath(selectedImageUri);
}
if (!remotepath.endsWith(OCFile.PATH_SEPARATOR))
remotepath += OCFile.PATH_SEPARATOR;
- remotepath += new File(filepath).getName();
+
+ if (filepath.startsWith(UriUtils.URI_CONTENT_SCHEME)) {
+
+ Cursor cursor = MainApp.getAppContext().getContentResolver()
+ .query(Uri.parse(filepath), null, null, null, null, null);
+
+ try {
+ if (cursor != null && cursor.moveToFirst()) {
+ String displayName = cursor.getString(
+ cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
+ Log.i(TAG, "Display Name: " + displayName + "; mimeType: " + mimeType);
+
+ displayName.replace(File.separatorChar, '_');
+ displayName.replace(File.pathSeparatorChar, '_');
+ remotepath += displayName + DisplayUtils.getComposedFileExtension(filepath);
+
+ }
+ } finally {
+ cursor.close();
+ }
+
+ } else {
+ remotepath += new File(filepath).getName();
+ }
i.putExtra(FileUploader.KEY_LOCAL_FILE, filepath);
i.putExtra(FileUploader.KEY_REMOTE_FILE, remotepath);
+ i.putExtra(FileUploader.KEY_MIME_TYPE, mimeType);
i.putExtra(FileUploader.KEY_UPLOAD_TYPE, FileUploader.UPLOAD_SINGLE_FILE);
if (resultCode == UploadFilesActivity.RESULT_OK_AND_MOVE)
i.putExtra(FileUploader.KEY_LOCAL_BEHAVIOUR, FileUploader.LOCAL_BEHAVIOUR_MOVE);
return dialog;
}
-
/**
- * Translates a content URI of an image to a physical path
- * on the disk
+ * Translates a content URI of an content to a physical path on the disk
+ *
* @param uri The URI to resolve
- * @return The path to the image or null if it could not be found
+ * @return The path to the content or null if it could not be found
*/
public String getPath(Uri uri) {
- String[] projection = { MediaStore.Images.Media.DATA };
- Cursor cursor = managedQuery(uri, projection, null, null, null);
- if (cursor != null) {
- int column_index = cursor
- .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
- cursor.moveToFirst();
- return cursor.getString(column_index);
- }
+ final boolean isKitKatOrLater = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
+
+ // DocumentProvider
+ if (isKitKatOrLater && DocumentsContract.isDocumentUri(getApplicationContext(), uri)) {
+ // ExternalStorageProvider
+ if (UriUtils.isExternalStorageDocument(uri)) {
+ final String docId = DocumentsContract.getDocumentId(uri);
+ final String[] split = docId.split(":");
+ final String type = split[0];
+
+ if ("primary".equalsIgnoreCase(type)) {
+ return Environment.getExternalStorageDirectory() + "/" + split[1];
+ }
+ }
+ // DownloadsProvider
+ else if (UriUtils.isDownloadsDocument(uri)) {
+
+ final String id = DocumentsContract.getDocumentId(uri);
+ final Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"),
+ Long.valueOf(id));
+
+ return UriUtils.getDataColumn(getApplicationContext(), contentUri, null, null);
+ }
+ // MediaProvider
+ else if (UriUtils.isMediaDocument(uri)) {
+ final String docId = DocumentsContract.getDocumentId(uri);
+ final String[] split = docId.split(":");
+ final String type = split[0];
+
+ Uri contentUri = null;
+ if ("image".equals(type)) {
+ contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+ } else if ("video".equals(type)) {
+ contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+ } else if ("audio".equals(type)) {
+ contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+ }
+
+ final String selection = "_id=?";
+ final String[] selectionArgs = new String[] { split[1] };
+
+ return UriUtils.getDataColumn(getApplicationContext(), contentUri, selection, selectionArgs);
+ }
+ // Documents providers returned as content://...
+ else if (UriUtils.isContentDocument(uri)) {
+ return uri.toString();
+ }
+ }
+ // MediaStore (and general)
+ else if ("content".equalsIgnoreCase(uri.getScheme())) {
+
+ // Return the remote address
+ if (UriUtils.isGooglePhotosUri(uri))
+ return uri.getLastPathSegment();
+
+ return UriUtils.getDataColumn(getApplicationContext(), uri, null, null);
+ }
+ // File
+ else if ("file".equalsIgnoreCase(uri.getScheme())) {
+ return uri.getPath();
+ }
return null;
}
return url;\r
}\r
}\r
- \r
+\r
+ /**\r
+ * Get the file extension if it is on path as type "content://.../DocInfo.doc"\r
+ * @param filepath: Content Uri converted to string format\r
+ * @return String: fileExtension (type '.pdf'). Empty if no extension\r
+ */\r
+ public static String getComposedFileExtension(String filepath) {\r
+ String fileExtension = "";\r
+ String fileNameInContentUri = filepath.substring(filepath.lastIndexOf("/"));\r
+\r
+ // Check if extension is included in uri\r
+ int pos = fileNameInContentUri.lastIndexOf('.');\r
+ if (pos >= 0) {\r
+ fileExtension = fileNameInContentUri.substring(pos);\r
+ }\r
+ return fileExtension;\r
+ }\r
+\r
public static CharSequence getRelativeDateTimeString(Context c, long time, long minResolution, long transitionResolution, int flags){\r
CharSequence dateString = "";\r
\r
}\r
}\r
\r
- return dateString.toString().split(",")[0];\r
+ return dateString.toString().split(",")[0];
}\r
}\r
--- /dev/null
+/* ownCloud Android client application
+ * Copyright (C) 2012-2014 ownCloud Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package com.owncloud.android.utils;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+
+
+/**
+ * A helper class for some Uri operations.
+ */
+public class UriUtils {
+
+ public static final String URI_CONTENT_SCHEME = "content://";
+
+
+ /**
+ * Get the value of the data column for this Uri. This is useful for
+ * MediaStore Uris, and other file-based ContentProviders.
+ *
+ * @param context The context.
+ * @param uri The Uri to query.
+ * @param selection (Optional) Filter used in the query.
+ * @param selectionArgs (Optional) Selection arguments used in the query.
+ * @return The value of the _data column, which is typically a file path.
+ */
+ public static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
+
+ Cursor cursor = null;
+ final String column = "_data";
+ final String[] projection = { column };
+
+ try {
+ cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
+ if (cursor != null && cursor.moveToFirst()) {
+
+ final int column_index = cursor.getColumnIndexOrThrow(column);
+ return cursor.getString(column_index);
+ }
+ } finally {
+ if (cursor != null)
+ cursor.close();
+ }
+ return null;
+ }
+
+ /**
+ * @param uri The Uri to check.
+ * @return Whether the Uri authority is ExternalStorageProvider.
+ */
+ public static boolean isExternalStorageDocument(Uri uri) {
+ return "com.android.externalstorage.documents".equals(uri.getAuthority());
+ }
+
+ /**
+ * @param uri The Uri to check.
+ * @return Whether the Uri authority is DownloadsProvider.
+ */
+ public static boolean isDownloadsDocument(Uri uri) {
+ return "com.android.providers.downloads.documents".equals(uri.getAuthority());
+ }
+
+ /**
+ * @param uri The Uri to check.
+ * @return Whether the Uri authority is MediaProvider.
+ */
+ public static boolean isMediaDocument(Uri uri) {
+ return "com.android.providers.media.documents".equals(uri.getAuthority());
+ }
+
+ /**
+ * @param uri The Uri to check.
+ * @return Whether the Uri authority is Google Photos.
+ */
+ public static boolean isGooglePhotosUri(Uri uri) {
+ return "com.google.android.apps.photos.content".equals(uri.getAuthority());
+ }
+
+ /**
+ *
+ * @param uri The Uri to check.
+ * @return Whether the Uri is from a content provider as kind "content://..."
+ */
+ public static boolean isContentDocument(Uri uri) {
+ return uri.toString().startsWith(URI_CONTENT_SCHEME);
+ }
+}
projects / pub / Android / ownCloud.git / commitdiff