No meu aplicativo, deixei o usuário ter a chance de tirar uma foto e defini-la como foto de perfil. Existem duas maneiras de obter a foto, da galeria, e tirada diretamente com a câmera.

Eu escrevi código que funciona com métodos de booth e testei em um Galaxy S5 com pirulito 5.0. Ao testá-lo com um KitKat 4.4.4, ele lança um NPE. Mas está jogando esse NPE apenas ao tirar a foto diretamente da câmera.

Nos casos de estande, esta é a estrutura que sigo:

Obtenha o Uri a partir dos dados da chamada onActivityResult.Obter o valor da orientação da foto (em alguns casos, a imagem em retrato aparece girada na visualização de imagem).Decodifique o bitmap para reduzi-lo, mantendo a proporção.Gire a imagem se a orientação estiver errada.Salve o bitmap nos dados internos do aplicativo.

E este é o código para a solicitação "tirar foto da câmera":

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    switch (requestCode) {
        case TAKE_PHOTO_REQUEST_FRAG:
            if (resultCode == getActivity().RESULT_OK && data != null) {

                Uri selectedImageUri = data.getData();
                Bitmap srcBmp = null;

                /*Get image orientation*/
                int orientation = getImageOrientation(getActivity(), selectedImageUri);
                Log.d("IMAGE_ORIENTATION", String.valueOf(orientation));

                /*Downsize bitmap mantaining aspect ratio*/
                srcBmp = decodeSampledBitmapFromUri(
                        selectedImageUri,
                        pic_view.getWidth(), pic_view.getHeight());

                /*Rotate image if needed*/
                if (orientation == 90) {
                    Matrix matrix = new Matrix();
                    matrix.postRotate(90);
                    srcBmp = Bitmap.createBitmap(srcBmp, 0, 0,
                            srcBmp.getWidth(), srcBmp.getHeight(), matrix,
                            true);
                }
                else if (orientation == 180) {
                    Matrix matrix = new Matrix();
                    matrix.postRotate(180);
                    srcBmp = Bitmap.createBitmap(srcBmp, 0, 0,
                            srcBmp.getWidth(), srcBmp.getHeight(), matrix,
                            true);
                }
                else if (orientation == 270) {
                    Matrix matrix = new Matrix();
                    matrix.postRotate(270);
                    srcBmp = Bitmap.createBitmap(srcBmp, 0, 0,
                            srcBmp.getWidth(), srcBmp.getHeight(), matrix,
                            true);
                }

                /*Save bitmap in internal memory*/
                ContextWrapper cw1 = new ContextWrapper(getActivity().getApplicationContext());
                File directory1 = cw1.getDir("profile", Context.MODE_PRIVATE);
                if (!directory1.exists()) {
                    directory1.mkdir();
                }
                File filepath1 = new File(directory1, "profile_pic.png");
                FileOutputStream fos1 = null;
                try {
                    fos1 = new FileOutputStream(filepath1);
                    srcBmp.compress(Bitmap.CompressFormat.JPEG, 90, fos1);
                    fos1.close();
                } catch (Exception e) {
                    Log.e("SAVE_FULL_IMAGE", e.getMessage(), e);
                }

                /*Show image in imageview*/
                pic_view.setImageBitmap(srcBmp);
            }
            break;
    }
}

-

/*Downsize the bitmap from uri*/
public Bitmap decodeSampledBitmapFromUri(Uri uri, int reqWidth, int reqHeight) {
    Bitmap bm = null;
    try{
        // First decode with inJustDecodeBounds=true to check dimensions
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(getActivity().getContentResolver().openInputStream(uri), null, options);

        // Calculate inSampleSize
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        bm = BitmapFactory.decodeStream(getActivity().getContentResolver().openInputStream(uri), null, options);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        Toast.makeText(getActivity().getApplicationContext(), e.toString(), Toast.LENGTH_LONG).show();
    }
    return bm;
}


public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    // Raw height and width of image
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {
        if (width > height) {
            inSampleSize = Math.round((float)height / (float)reqHeight);
        } else {
            inSampleSize = Math.round((float)width / (float)reqWidth);
        }
    }
    return inSampleSize;
}

-

/*Get image orientation first from Exif info*/
public int getImageOrientation(Context context, Uri photoUri) {
    int orientation = getOrientationFromExif(photoUri);
    if(orientation <= 0) {
        orientation = getOrientationFromMediaStore(context, photoUri);
    }
    return orientation;
}

private int getOrientationFromExif(Uri photoUri) {
    int orientation = -1;
    try {
        ExifInterface exif = new ExifInterface(photoUri.getPath());
        int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_NORMAL);

        switch (exifOrientation) {
            case ExifInterface.ORIENTATION_ROTATE_270:
                orientation = 270;
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                orientation = 180;
                break;
            case ExifInterface.ORIENTATION_ROTATE_90:
                orientation = 90;
                break;
            case ExifInterface.ORIENTATION_NORMAL:
                orientation = 0;
                break;
            default:
                break;
        }
    } catch (IOException e) {
        Log.e("EXIF_ORIENTATION", "Unable to get image exif orientation", e);
    }
    return orientation;
}

/* normal landscape: 0
 * normal portrait: 90
 * upside-down landscape: 180
 * upside-down portrait: 270
 * image not found: -1
 */
private static int getOrientationFromMediaStore(Context context, Uri photoUri) {
    String[] projection = {MediaStore.Images.ImageColumns.ORIENTATION};
    Cursor cursor = context.getContentResolver().query(photoUri, projection, null, null, null);

    try {
        if (cursor.moveToFirst()) {
            return cursor.getInt(0);
        } else {
            return -1;
        }
    } finally {
        cursor.close();
    }
}

Ele está lançando o NPE na linha em que desejo obter a orientação da imagem a partir dos dados exif, exatamente onde recebo o Path da uri:

ExifInterface exif = new ExifInterface(photoUri.getPath());

Então eu sei que deve ser algo com o caminho. Eu li vários posts sobre o kitkat que retorna o caminho em um formato diferente. Eu tentei diferentes métodos getPath () personalizados, mas sempre lança o NPE ao chamar o Cursor.