web-dev-qa-db-fra.com

Android: l'application se bloque sur onActivityResult lors de l'utilisation de Camera Intent

J'utilise l'objectif de la caméra pour capturer des images dans mon application. Le problème sur lequel mon application se bloque sur Android 5.0.2 lors de l'utilisation de l'appareil photo. J'utilise l'intention du fragment. Ci-dessous est mon code à l'intérieur du fragment:

Méthode pour prendre une photo

private void takePhoto() {
    mHighQualityImageUri = Util.generateTimeStampPhotoFileUri(getActivity());
    Log.d(UploadPicturesFragment.class.getSimpleName(),
            "URI: " + mHighQualityImageUri.toString());
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, mHighQualityImageUri);
    startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
}

onActivityResult dans mon fragment

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (resultCode != Activity.RESULT_OK) {
        return;
    }

    if (requestCode == REQUEST_IMAGE_CAPTURE) {
    Log.d(UploadPicturesFragment.class.getSimpleName(),
                "IMAGE URI NOT NULL: " + (mHighQualityImageUri == null));
        try {
            Bitmap bitmap = MediaStore.Images.Media.getBitmap(getActivity().getContentResolver(),
                    mHighQualityImageUri);
            DroomUtil.beginCrop(mHighQualityImageUri, getActivity(), this, true, bitmap.getWidth(),
                    bitmap.getHeight());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Trace de journal

12-29 10:28:03.491: E/AndroidRuntime(9780): Java.lang.RuntimeException:       Unable to resume activity {in.droom/in.droom.activity.MainActivity}:     Java.lang.RuntimeException: Failure delivering result    ResultInfo{who=Android:fragment:2, request=1, result=-1, data=null} to activity   {in.droom/in.droom.activity.MainActivity}: Java.lang.NullPointerException:   Attempt to invoke virtual method 'Java.lang.String Android.net.Uri.getScheme()'   on a null object reference
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.performResumeActivity(ActivityThread.Java:3224)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.handleResumeActivity(ActivityThread.Java:3257)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.handleLaunchActivity(ActivityThread.Java:2479)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.access$800(ActivityThread.Java:144)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread$H.handleMessage(ActivityThread.Java:1359)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.os.Handler.dispatchMessage(Handler.Java:102)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.os.Looper.loop(Looper.Java:155)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.main(ActivityThread.Java:5702)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Java.lang.reflect.Method.invoke(Native Method)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Java.lang.reflect.Method.invoke(Method.Java:372)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at com.Android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.Java:1029)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at com.Android.internal.os.ZygoteInit.main(ZygoteInit.Java:824)
12-29 10:28:03.491: E/AndroidRuntime(9780): Caused by: Java.lang.RuntimeException: Failure delivering result ResultInfo{who=Android:fragment:2, request=1, result=-1, data=null} to activity {in.droom/in.droom.activity.MainActivity}: Java.lang.NullPointerException: Attempt to invoke virtual method 'Java.lang.String Android.net.Uri.getScheme()' on a null object reference
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.deliverResults(ActivityThread.Java:3881)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.performResumeActivity(ActivityThread.Java:3197)
12-29 10:28:03.491: E/AndroidRuntime(9780):     ... 11 more
12-29 10:28:03.491: E/AndroidRuntime(9780): Caused by: Java.lang.NullPointerException: Attempt to invoke virtual method 'Java.lang.String Android.net.Uri.getScheme()' on a null object reference
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.content.ContentResolver.openInputStream(ContentResolver.Java:651)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.provider.MediaStore$Images$Media.getBitmap(MediaStore.Java:1019)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at in.droom.fragments.UploadPicturesFragment.onActivityResult(UploadPicturesFragment.Java:395)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.Activity.dispatchActivityResult(Activity.Java:6164)
12-29 10:28:03.491: E/AndroidRuntime(9780):     at Android.app.ActivityThread.deliverResults(ActivityThread.Java:3877)
12-29 10:28:03.491: E/AndroidRuntime(9780):     ... 12 more

La ligne no. 395 est:

Bitmap bitmap = MediaStore.Images.Media.getBitmap(getActivity().getContentResolver(),
                    mHighQualityImageUri);
androidandroid-camera-intent
17
Nitish
Caused by: Java.lang.NullPointerException: Attempt to invoke virtual method 'Java.lang.String Android.net.Uri.getScheme()' on a null object reference

Cela signifie que mHighQualityImageUri est null, selon toute vraisemblance. Cela se produira si vous n'avez pas réussi à conserver ce Uri à l'aide de onSaveInstanceState(). Il est tout à fait possible que votre processus soit interrompu alors que votre application est en arrière-plan et l'application appareil photo est au premier plan.

12
CommonsWare

Suivez les étapes ci-dessous pour prendre une photo de l'appareil photo et l'afficher sur ImageView

1) Démarrer l'intention de la caméra 

Uri fileUri;
String photoPath = "";

 private void startingCameraIntent()
    {
        String fileName = System.currentTimeMillis()+".jpg";
        ContentValues values = new ContentValues();
        values.put(MediaStore.Images.Media.TITLE, fileName);
        fileUri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);

        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
        startActivityForResult(intent, YOUR_REQ_CODE);
    }

2) Fonction de rappel onActivityResult 

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data)
    {
        if (resultCode == Activity.RESULT_OK)
        {
            try
            {
                photoPath = getPath(fileUri);

                System.out.println("Image Path : " + photoPath);

                Bitmap b = decodeUri(fileUri);
                your_image_view.setImageBitmap(b);
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }

3) Fonction decodeUri 

private Bitmap decodeUri(Uri selectedImage) throws FileNotFoundException
    {
        BitmapFactory.Options o = new BitmapFactory.Options();

        o.inJustDecodeBounds = true;

        BitmapFactory.decodeStream(getContentResolver()
                                           .openInputStream(selectedImage), null, o);

        final int REQUIRED_SIZE = 72;

        int width_tmp = o.outWidth, height_tmp = o.outHeight;

        int scale = 1;

        while (true)
        {
            if (width_tmp / 2 < REQUIRED_SIZE || height_tmp / 2 < REQUIRED_SIZE)
            {
                break;
            }
            width_tmp /= 2;

            height_tmp /= 2;

            scale *= 2;
        }

        BitmapFactory.Options o2 = new BitmapFactory.Options();

        o2.inSampleSize = scale;

        Bitmap bitmap = BitmapFactory.decodeStream(getContentResolver()
                                                           .openInputStream(selectedImage), null, o2);

        return bitmap;
    }

4) getPath de l'image 

@SuppressWarnings("deprecation")
    private String getPath(Uri selectedImaeUri)
    {
        String[] projection = { MediaStore.Images.Media.DATA };

        Cursor cursor = managedQuery(selectedImaeUri, projection, null, null,
                                     null);

        if (cursor != null)
        {
            cursor.moveToFirst();

            int columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);

            return cursor.getString(columnIndex);
        }

        return selectedImaeUri.getPath();
    }

Enfin Dans le manifeste, définissez l'autorisation

 <uses-permission Android:name="Android.permission.WRITE_EXTERNAL_STORAGE"/>

Remarque: Si vous utilisez Marshmallow (Android 6.0), vous devez définir les contrôles d'autorisation avant d'utiliser application appareil photo. Vous pouvez lire sur Android Demande d'autorisations au moment de l'exécution

6
Zubair Ahmed

Tout d'abord, vérifiez si data est null dans onActivityResult en ajoutant un code supplémentaire qui empêchera votre application de se bloquer , comme ça

public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode != Activity.RESULT_OK && data !=null) {
    return;
}
}

Considérez alors cette leçon qui explique comment capturer des photos à l'aide d'une application d'appareil photo existante.

Il existe une référence complète sur Demande d'autorisation de l'appareil photo utilisant tilise la balise de fonctionnalité , Obtention d'une miniature , Enregistrement de la photo en taille réelle =, Et bien d'autres qui peuvent vous être très utiles pour accomplir votre tâche ...

4
Shree Krishna
    please check your path from mHighQualityImageUri because output path is not found, below code is modify please check it, it work and remember camera result is give in Main Activity class because You used Fragment so declare on activity Result in Main Activity (Fragment Activity) class.   
//on Fragment Class
private void takePhoto() {
             /*   mHighQualityImageUri = Util.generateTimeStampPhotoFileUri(getActivity());
                Log.d(UploadPicturesFragment.class.getSimpleName(),
                        "URI: " + mHighQualityImageUri.toString());*/
                imageUri =Uri.fromFile(new File("/sdcard/"));
                Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                intent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
                context.startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
            }

    //on Main Activity Class
      @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            if (requestCode == 1) {
             /*   Log.d(UploadPicturesFragment.class.getSimpleName(),
                        "IMAGE URI NOT NULL: " + (mHighQualityImageUri == null));*/
                try {

                    /*if(imageUri==null){
                        Log.i("Bitmap", "Image URI Null");
                    }else {
                        Log.i("Bitmap","Image URI is not Null");
                    }*/
                    Uri imageUri = Uri.fromFile(new File("/sdcard/"));
                    Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(),imageUri);
    //                        mHighQualityImageUri);
                    if(bitmap !=null)
                    {
                        Log.i("Bitmap", "Bitmap not Null");
                    }else {
                        Log.i("Bitmap","Bitmap is Null");
                    }
                    //  DroomUtil.beginCrop(mHighQualityImageUri, getActivity(), this, true, bitmap.getWidth(),
                    // bitmap.getHeight());
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            super.onActivityResult(requestCode, resultCode, data);
        }
2
Krunal Patel

Sur Android, j'ai vu différents appareils présenter un comportement différent pour choisir l'image avec l'appareil photo et la galerie. Je trouve que la meilleure façon est de:

  1. Créez un fournisseur de contenu dans votre application.
  2. Obtenez un Uri auprès de votre fournisseur de contenu et transmettez-le à l'intention de la caméra.
  3. La caméra écrit l'image capturée sur votre Uri.
  4. Lisez-le à l'aide de context.getContentResolver (). OpenInputStream ().

Cette méthode rend votre code indépendant de l'URI retourné en intention puisque vous possédez l'URI. En outre, cela prend également en charge le choix d'image de galerie avec de petites modifications.

Je vois que vous avez également des problèmes d'orientation de l'appareil avec l'appareil photo. Cela (malheureusement) doit être traité dans votre application, une fois que vous avez acquis l'image dans une étape de post-traitement. J'ai également décrit le code ci-dessous. Surtout, des problèmes d'orientation se sont produits sur les appareils Samsung où l'appareil photo ne capturait que des images en mode paysage.

Création d'Uri pour l'image:

string imageId = "IMG" + System.currentTimeMillis();
Uri attachmentUri = Uri.parse("content://"+ AttachmentContentProvider.AUTHORITY + "/images/" + imageId); 
// Store this as a member in your activity/fragment as mAttachmentUri

Remarque: il est important que vous persistiez mAttachmentUri à l'aide de préférences partagées ou d'un groupe d'activités à l'aide de onSaveInstanceState (), sinon l'URI peut être perdu lorsque votre application est tuée.

Obtenir l'intention de la caméra:

public static Intent getImageCaptureIntent(Context context, Uri outputFileUri)
{
    Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
    return cameraIntent;
}

Lecture de l'image:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) 
{
    if (resultCode != Activity.RESULT_OK) {
        return;
    }

    if (requestCode == REQUEST_IMAGE_CAPTURE) 
    {

        try {
            Bitmap bitmap = decodeSampledBitmapFromResource(getActivity(), mAttachmentUri, Config.RGB_565);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    public static Bitmap decodeSampledBitmapFromResource(Context context, Uri uri, Config config)
    { 
        Bitmap bmp = null;
        InputStream is = null;
        if (uri != null)
        {
            try
            {
                is = context.getContentResolver().openInputStream(uri);

                boolean resize = true;
                // First decode with inJustDecodeBounds=true to check dimensions
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inJustDecodeBounds = true;
                BitmapFactory.decodeStream(is, null, options);
                mLogger.d("Image Original Width:" + options.outWidth + " Height:" + options.outHeight );
                // close and open the stream again
                is.close();

                is = context.getContentResolver().openInputStream(uri);
                int reqWidth = options.outWidth;
                int reqHeight = options.outHeight;

                // Decode bitmap with inSampleSize set
                options.inJustDecodeBounds = false;
                options.inPreferredConfig = config;     
                bmp = BitmapFactory.decodeStream(is, null, options);

                if(bmp != null)
                {
                    bmp = correctImageRotation(context, bmp, uri);
                }
                else
                {
                    mLogger.e("BitmapFactory.decodeStream returned null bitmap , skip correctImageRotation");
                }
            }
            catch (FileNotFoundException fnfex)
            {
                mLogger.e("FileNotFoundException : while decoding inline image bitmap: " + fnfex.getMessage());
            }
            catch (IOException ioex)
            {
                mLogger.e("IOException : while decoding inline image bitmap: " + ioex.getMessage());
            }
            catch (OutOfMemoryError e)
            {
                mLogger.e("OutOfMemoryError : in decodeSampledBitmapFromResource BitmapFactory.decodeStream . Skip loading Resource");
            }
            finally
            {
                try
                {
                    if (is != null)
                    {
                        is.close();
                    }
                }
                catch (IOException ioex2)
                {
                    mLogger.e("IOException2 : while decoding inline image bitmap: " + ioex2.getMessage());
                }
            }
        }
        return bmp;
    }

    // Seemed necessary on a lot of Samsung devices
    public static Bitmap correctImageRotation( Context context, Bitmap bitmap , Uri inputUri ) throws FileNotFoundException
    {
        int orientation = ExifInterface.ORIENTATION_UNDEFINED;

        try
        {
            String appfilesDir = context.getApplicationContext().getFilesDir().getAbsolutePath();
            String attachmentDirPath = appfilesDir + ('/') + "images");
            String fileName = ContentUris.parseId(uri) + ".jpg";
            String absolutePath = attachmentDirPath + ('/') + fileName;
            ExifInterface exif = new ExifInterface(path);
            orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
        }
        catch (IOException e)
        {
        }

        return rotateBitmap(bitmap, orientation);
    }

    /**
     * rotate bitmap code reference:
     * http://stackoverflow.com/questions/20478765/how-to-get-the-correct-orientation-of-the-image-selected-from-the-default-image
     */
    private static Bitmap rotateBitmap(Bitmap bitmap, int orientation)
    {
        Matrix matrix = new Matrix();
        switch (orientation)
        {
        case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
            matrix.setScale(-1, 1);
            break;
        case ExifInterface.ORIENTATION_ROTATE_180:
            matrix.setRotate(180);
            break;
        case ExifInterface.ORIENTATION_FLIP_VERTICAL:
            matrix.setRotate(180);
            matrix.postScale(-1, 1);
            break;
        case ExifInterface.ORIENTATION_TRANSPOSE:
            matrix.setRotate(90);
            matrix.postScale(-1, 1);
            break;
        case ExifInterface.ORIENTATION_ROTATE_90:
            matrix.setRotate(90);
            break;
        case ExifInterface.ORIENTATION_TRANSVERSE:
            matrix.setRotate(-90);
            matrix.postScale(-1, 1);
            break;
        case ExifInterface.ORIENTATION_ROTATE_270:
            matrix.setRotate(-90);
            break;
        case ExifInterface.ORIENTATION_NORMAL:
        case ExifInterface.ORIENTATION_UNDEFINED:
        default:
            return bitmap;
        }
        try
        {
            Bitmap bmRotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
            bitmap.recycle();
            return bmRotated;
        }
        catch (OutOfMemoryError e)
        {
            mLogger.e("OutOfMemoryError occured while rotating the image");
            return bitmap;
        }
    }

Fournisseur de contenu:

Pour l'implémentation du fournisseur de contenu, vous pouvez utiliser FileProvider d'un Android ou implémenter un fournisseur de contenu comme ci-dessous. Ce fournisseur de contenu ouvrira un fichier dans votre conteneur d'applications pour que l'application appareil photo puisse y écrire.

public class AttachmentContentProvider extends ContentProvider 
{
    public static final String AUTHORITY = "com.yourcompany.yourapp.AttachmentContentProvider";
    public static final int ENTITY_ATTACHMENT = 1;
    public static final int ENTITY_ATTACHMENT_ID = 2;

    private static final UriMatcher sUriMatcher;
    static 
    {
        sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        sUriMatcher.addURI(AUTHORITY, "images", ENTITY_ATTACHMENT);
        sUriMatcher.addURI(AUTHORITY, "images"+"/#", ENTITY_ATTACHMENT_ID);
    }

    @Override
    public boolean onCreate()
    {
        return true;
    }

    @Override
    public int delete(Uri uri, String where, String[] whereArgs)
    {
        return 0;
    }

    @Override
    public String getType(Uri uri)
    {
        int match = sUriMatcher.match(uri);
        switch (match) 
        {
        case ENTITY_ATTACHMENT:
        case ENTITY_ATTACHMENT_ID:
            return "image/jpeg";

        default:
            return null;
        }
    }

    @Override
    public Uri insert(Uri uri, ContentValues initialValues)
    {
        return null;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)
    {
        return null;
    }

    @Override
    public int update(Uri uri, ContentValues values, String where, String[] whereArgs)
    {
        return 0;
    }

    public static File getAttachmentFile(String fileName)
    {
        String appfilesDir = context.getApplicationContext().getFilesDir().getAbsolutePath();
        String attachmentDirPath = appfilesDir + ('/') + "images");
        File newFile = new File(AttachmentHelper.getAttachmentsDir() + File.separator + fileName);
        newFile.getParentFile().mkdirs();
        return newFile;
    }


    @Override
    public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException 
    {
        long id = -1;
        try
        {
            id = ContentUris.parseId(uri);
        }
        catch (NumberFormatException e)
        {
            m_logger.e("Invalid id for Uri : " + uri );
        }

        String filename  = id + ".jpg"; // id will be IMG+current time millis
        File imageFile = getAttachmentFile(id); 
        return (ParcelFileDescriptor.open(file, parseMode(mode)));
    }
}

Pour résumer, ce code devrait fonctionner sur la plupart des appareils testés et corrige l'image reçue de la caméra si nécessaire.

2
Rohan

Selon les journaux

Caused by: Java.lang.NullPointerException: Attempt to invoke virtual method 'Java.lang.String Android.net.Uri.getScheme()' on a null object reference

Il indique clairement que vous appelez getScheme() sur un objet nul. Donc, avant le traitement, vous devez vérifier les données d'intention nulle.

En outre, en commençant par Android M, vous devez demander à l'utilisateur l'autorisation de l'appareil photo. En l'absence d'autorisation de l'appareil photo, l'application se bloquera.

Pour savoir comment travailler avec une nouvelle architecture d'autorisation, regardez-la: http://developer.Android.com/training/permissions/index.html

2
Geeky Singh

Je pense que si vous utilisez l'intention de fragment et si vous utilisez getActivity() assurez-vous que vous avez attaché votre fragment à votre activité sinon il peut vous jeter un pointeur nul. donc dans mon cas, j'ai utilisé une solution de contournement pour obtenir le contexte, que vous pouvez utiliser

créez une variable globale View rootView et initialisez-la OnViewCreated() method et vous pouvez l'utiliser en conséquence.

public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode != Activity.RESULT_OK) {
    return;
}

if (requestCode == REQUEST_IMAGE_CAPTURE) {
Log.d(UploadPicturesFragment.class.getSimpleName(),
            "IMAGE URI NOT NULL: " + (mHighQualityImageUri == null));
    try {
        Bitmap bitmap = MediaStore.Images.Media.getBitmap( rootView.getContext().getContentResolver(),
                mHighQualityImageUri);
        DroomUtil.beginCrop(mHighQualityImageUri, rootView.getContext(), this, true, bitmap.getWidth(),
                bitmap.getHeight());
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}}
0
Sunny Jain

Voici ce que je fais souvent dans mes projets, jetez un œil. J'espère que cela aide!

Classe de fragment: 

btnCapturePicture.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {       
        captureImage();     
    }
});

btnSelectPicture.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {       
        selectImage();
    }
});

...

private void captureImage() {
    mFileUri = Uri.fromFile(Utils.getOutputMediaFile(MEDIA_TYPE_IMAGE));
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, mFileUri);
    startActivityForResult(intent, CAMERA_CAPTURE_IMAGE_REQUEST_CODE);
}

private void selectImage() {    
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.setType(MIME_IMAGE_ALL); 
    startActivityForResult(intent, SELECT_PHOTO_CODE);
}

...

@Override
public void onActivityResult(int requestCode, int resultCode, Intent imageReturnedIntent) {
    super.onActivityResult(requestCode, resultCode, imageReturnedIntent);

    switch (requestCode) {
        case SELECT_PHOTO_CODE:
            if (resultCode == Activity.RESULT_OK) {
                mFileUri = imageReturnedIntent.getData();
                if (mFileUri != null) {
                    mFilePath = Utils.getRealPathFromUri(mContext, mFileUri);
                    mFilePath = mFilePath.replace("file://", "");
                    // do something such as display ImageView...
                }
            }
            break;
        case CAMERA_CAPTURE_IMAGE_REQUEST_CODE:
            if (resultCode == Activity.RESULT_OK) {
                if (mFileUri != null) {
                    mFilePath = mFileUri.toString();
                    mFilePath = mFilePath.replace("file://", "");
                    // do something such as display ImageView...
                }
            }
            break;
    }

    // refresh phone's folder content
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KitKat) {
        Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);     
        mediaScanIntent.setData(mFileUri);
        getActivity().sendBroadcast(mediaScanIntent);
    } else {
        getActivity().sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED, Uri.parse("file://" + Environment.getExternalStorageDirectory())));
    }
}

Classe Utils: 

//returning image, video
public static File getOutputMediaFile(int type) {

    // External sdcard location
    File mediaStorageDir = new File(Environment.getExternalStorageDirectory(), "DCIM/Camera");

    // Create the storage directory if it does not exist
    if (!mediaStorageDir.exists()) {
        if (!mediaStorageDir.mkdirs()) {
            return null;
        }
    }

    // Create a media file name
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
    File mediaFile;
    if (type == MEDIA_TYPE_IMAGE) {
        mediaFile = new File(mediaStorageDir.getPath() + File.separator + "IMG_" + timeStamp + ".jpg");
    } else if (type == MEDIA_TYPE_VIDEO) {
        mediaFile = new File(mediaStorageDir.getPath() + File.separator + "VID_" + timeStamp + ".mp4");
    } else {
        return null;
    }

    return mediaFile;
}

//For select picture
public static String getRealPathFromUri(Context context, Uri contentUri) {
    Cursor cursor = null;
    try {
        String[] proj = {MediaStore.Images.Media.DATA};
        cursor = context.getContentResolver().query(contentUri, proj, null, null, null);
        int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
    } finally {
        if (cursor != null) {
            cursor.close();
        }
    }
}
0
BNK