result_ok - Android: la aplicación se bloquea en onActivityResult al usar Camera Intent

setresult android

Question

Estoy usando la cámara para capturar imágenes en mi aplicación. El problema de mi aplicación se bloquea en Android 5.0.2 al usar la cámara. Estoy usando la intención del fragmento. A continuación se muestra mi código dentro del fragmento:

Método para tomar una foto

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 en mi fragmento

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();
        }
    }
}

Registro de seguimiento

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 línea no. 395 es:

Bitmap bitmap = MediaStore.Images.Media.getBitmap(getActivity().getContentResolver(),
                    mHighQualityImageUri);

Answer 1

Creo que, si está usando la intención del fragmento y si está usando getActivity() asegúrese de haber adjuntado su fragmento a su actividad, de lo contrario podría arrojar un puntero nulo. por lo tanto, en mi caso, utilicé una solución para obtener el contexto, que puede usarlo

cree una variable View rootView e OnViewCreated() method y podrá usarlo en consecuencia.

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();
    }
}}

Answer 2

En Android, he visto diferentes dispositivos con diferentes comportamientos para elegir imágenes con cámara y galería. Encuentro que la mejor manera es:

1. Crea un proveedor de contenido en tu aplicación.
2. Obtenga un Uri de su proveedor de contenido y páselo a la intención de la cámara.
3. La cámara escribirá la imagen capturada en su Uri.
4. Léalo usando context.getContentResolver (). OpenInputStream ().

Este método hace que su código sea independiente del propósito de Uri devuelto ya que usted es dueño de Uri. Además, esto también es compatible con la selección de imágenes de la galería con pequeñas modificaciones.

Veo que tienes problemas de orientación del dispositivo también con la cámara. Esto (desafortunadamente) necesita ser procesado en su aplicación una vez que adquiera la imagen en un paso de procesamiento posterior. He esbozado el código para ello también a continuación. Principalmente, los problemas de orientación ocurrieron en dispositivos Samsung donde la cámara solo capturaba imágenes en modo horizontal.

Creando uri para la imagen:

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

Nota : es importante que mAttachmentUri usando preferencias compartidas o un paquete de actividades usando onSaveInstanceState () de lo contrario, el Uri puede perderse cuando tu aplicación muere.

Conseguir la intención de la cámara:

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

Leyendo la imagen:

@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://.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;
        }
    }

Proveedor de contenido:

Para la implementación del proveedor de contenido, puede usar el Proveedor de archivos de Android o implementar un proveedor de contenido como el siguiente. Este proveedor de contenido abrirá un archivo en el contenedor de aplicaciones para que la aplicación de la cámara escriba.

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)));
    }
}

Para resumir, este código debería funcionar en la mayoría de los dispositivos probados y corrige la imagen recibida de la cámara si es necesario.

Answer 3

En primer lugar, compruebe si los data están null en onActivityResult agregando un código adicional que evitará que su aplicación se bloquee , como esto

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

Luego considere esta lección que explica cómo capturar fotos usando una aplicación de cámara existente.

Hay una referencia completa sobre Solicitar permiso de la cámara usando la etiqueta de uso de funciones , Obtener una miniatura , Guardar una foto a tamaño completo , y muchos más que pueden ser muy útiles para realizar su tarea ...

Answer 4

Esto es lo que hago a menudo en mis proyectos, por favor, eche un vistazo. ¡Espero eso ayude!

Clase de fragmento

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())));
    }
}

Clase de 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();
        }
    }
}

Answer 5

Según los registros

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

Indica claramente que está llamando a getScheme() en un objeto nulo. Por lo tanto, antes de procesarlo, debe verificar los datos de intención nula.

Además, a partir de Android M, debe solicitar al usuario permiso para la cámara. A falta de permiso de la cámara, la aplicación se bloqueará.

Para saber cómo trabajar con una nueva arquitectura de permisos, http://developer.android.com/training/permissions/index.html : http://developer.android.com/training/permissions/index.html

Answer 6

Siga los pasos a continuación para tomar una fotografía de la cámara y mostrarla en ImageView

1) Iniciar la intención de la cámara

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) Función Callback 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) Función 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 of 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();
    }

Finalmente en Manifiesto se define el permiso.

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

Nota: si está utilizando marshmallow (Android 6.0), debe configurar los controles de permiso antes de usar la aplicación de la cámara. Puede leer sobre los permisos de solicitud de Android en tiempo de ejecución

Answer 7

    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);
        }

Answer 8

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

Eso significa que mHighQualityImageUri es null , con toda probabilidad. Esto ocurrirá si no pudo mantener ese Uri usando onSaveInstanceState() . Es completamente posible que su proceso finalice mientras su aplicación está en segundo plano y la aplicación de la cámara está en primer plano.