Created
August 18, 2017 08:49
-
-
Save JonathandelaSen/9d603153b55790b7e9bdf0592a1c7b62 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import android.annotation.SuppressLint; | |
import android.annotation.TargetApi; | |
import android.app.Activity; | |
import android.content.ContentUris; | |
import android.content.Context; | |
import android.content.Intent; | |
import android.database.Cursor; | |
import android.graphics.Bitmap; | |
import android.net.Uri; | |
import android.os.Build; | |
import android.os.Environment; | |
import android.provider.DocumentsContract; | |
import android.provider.MediaStore; | |
import android.webkit.MimeTypeMap; | |
import com.example.jonathan.medsblaprueba.exceptions.NoExtensionException; | |
import com.example.jonathan.medsblaprueba.models.MyMessage; | |
import java.io.ByteArrayOutputStream; | |
/** | |
* Created by jonathan on 27/04/17. | |
*/ | |
public class UtilsFilePath { | |
private static final String IMAGE_MIME = "image"; | |
private static final String VIDEO_MIME = "video"; | |
private static final String PDF_MIME = "pdf"; | |
private static final String DOC_MIME = "doc"; | |
private static final String DOCX_MIME = "docx"; | |
public static void openGallery(Activity activity, int requestCode) { | |
Intent i = new Intent(Intent.ACTION_PICK, | |
android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI); | |
i.setType("image/* video/*"); | |
activity.startActivityForResult(i, requestCode); | |
} | |
public static void openFileChooser(Activity activity, int requestCode) { | |
Intent intent = new Intent(Intent.ACTION_GET_CONTENT); | |
intent.setType("*/*"); | |
intent.addCategory(Intent.CATEGORY_OPENABLE); | |
activity.startActivityForResult(intent, requestCode); | |
} | |
/** | |
* Method for return file path of Gallery image | |
* | |
* @param context | |
* @param uri | |
* @return path of the selected image file from gallery | |
*/ | |
static String noPath = "Select Video Only"; | |
@TargetApi(Build.VERSION_CODES.KITKAT) | |
@SuppressLint("NewApi") | |
public static String getPath(final Context context, final Uri uri) { | |
// check here to KITKAT or new version | |
final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT; | |
// DocumentProvider | |
if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) { | |
// ExternalStorageProvider | |
if (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 (isDownloadsDocument(uri)) { | |
final String id = DocumentsContract.getDocumentId(uri); | |
final Uri contentUri = ContentUris.withAppendedId( | |
Uri.parse("content://downloads/public_downloads"), | |
Long.valueOf(id)); | |
return getDataColumn(context, contentUri, null, null); | |
} | |
// MediaProvider | |
else if (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 getDataColumn(context, contentUri, selection, | |
selectionArgs); | |
} | |
} | |
// MediaStore (and general) | |
else if ("content".equalsIgnoreCase(uri.getScheme())) { | |
// Return the remote address | |
if (isGooglePhotosUri(uri)) | |
return uri.getLastPathSegment(); | |
return getDataColumn(context, uri, null, null); | |
} | |
// File | |
else if ("file".equalsIgnoreCase(uri.getScheme())) { | |
return uri.getPath(); | |
} | |
return noPath; | |
} | |
/** | |
* Get the value of the data column for this Uri. This is <span id="IL_AD2" | |
* class="IL_AD">useful</span> 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 index = cursor.getColumnIndexOrThrow(column); | |
return cursor.getString(index); | |
} | |
} finally { | |
if (cursor != null) | |
cursor.close(); | |
} | |
return noPath; | |
} | |
/** | |
* @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()); | |
} | |
// public static String getMimeType(String filePath) { | |
// String type = null; | |
// String extension = MimeTypeMap.getFileExtensionFromUrl(filePath); | |
// if (extension != null) { | |
// type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension); | |
// } | |
// return type; | |
// } | |
public static boolean isPDFTypeFromPath(String path) throws NoExtensionException { | |
return getMimeType(path).contains(UtilsFilePath.PDF_MIME); | |
} | |
/* | |
public static boolean isImageType(String path) throws NoExtensionException { | |
return path != null && path.contains(UtilsFilePath.IMAGE_MIME); | |
//return getMimeType(path).contains(UtilsFilePath.IMAGE_MIME); | |
} | |
*/ | |
public static boolean isImageTypeFromPath(String path) throws NoExtensionException { | |
return getMimeType(path).contains(UtilsFilePath.IMAGE_MIME); | |
} | |
public static boolean isVideoTypeFromPath(String path) throws NoExtensionException { | |
return getMimeType(path).contains(UtilsFilePath.VIDEO_MIME); | |
} | |
public static boolean isDocTypeFromPath(String path) throws NoExtensionException { | |
return getMimeType(path).contains(UtilsFilePath.DOC_MIME) || getMimeType(path).contains(UtilsFilePath.DOCX_MIME); | |
} | |
public static int getTypeFromPath(String urlFile) { | |
try { | |
if (isImageTypeFromPath(urlFile)){ | |
return MyMessage.FILE_IMAGE_TYPE; | |
} | |
if (isVideoTypeFromPath(urlFile)){ | |
return MyMessage.FILE_VIDEO_TYPE; | |
} | |
if (UtilsFilePath.isDocTypeFromPath(urlFile)){ | |
return MyMessage.FILE_DOC_TYPE; | |
} | |
if (UtilsFilePath.isPDFTypeFromPath(urlFile)){ | |
return MyMessage.FILE_PDF_TYPE; | |
} | |
} catch (NoExtensionException e) { | |
e.printStackTrace(); | |
} | |
return MyMessage.FILE_OTHER_TYPE; | |
} | |
public static String getMimeType(String path) throws NoExtensionException { | |
String extension = MimeTypeMap.getFileExtensionFromUrl(path); | |
if (extension.isEmpty()){ | |
throw new NoExtensionException(); | |
} | |
return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension); | |
} | |
public static Uri getImageUri(Context inContext, Bitmap inImage) { | |
ByteArrayOutputStream bytes = new ByteArrayOutputStream(); | |
inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes); | |
String path = MediaStore.Images.Media.insertImage(inContext.getContentResolver(), inImage, "Title", null); | |
return Uri.parse(path); | |
} | |
public static String getFileName(String pathImage) { | |
String fileName = pathImage.substring(pathImage.lastIndexOf("/")+1); | |
return fileName.isEmpty() ? "" : fileName; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment