Android: Application se bloque sur onActivityResult tout en utilisant l'Appareil photo de l'Intention

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

Qui signifie mHighQualityImageUri est null, selon toute vraisemblance. Cela se produit si vous n'avez pas à accrocher à cette Uri à l'aide de onSaveInstanceState(). Il est tout à fait possible que votre processus sera terminé pendant que votre application est en arrière-plan et de l'application appareil photo est au premier plan.

Tout d'abord, vérifiez si data est null dans onActivityResult par l'ajout d'un code supplémentaire qui empêchera votre application d'être écrasé, à l'instar de ce

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

Alors Considérer Cette leçon Qui explique comment prendre des photos à l'aide d'une photo existante de l'application.

Il y a une référence complète sur Demandant l'autorisation caméra à l'aide de uses-feature tag , L'obtention d'une vignette, Enregistrement photo en grand format, Et beaucoup plus qui peuvent être très utiles à l'accomplissement de votre Tâche ...

Sur android, j'ai vu des différents dispositifs exibit des comportements différents pour le choix de l'image avec l'appareil photo et galerie. J'ai trouver la meilleure façon est de:

1. Créer un fournisseur de contenu dans votre application.
2. Obtenir une Uri à partir de votre fournisseur de contenu et le transmettre à l'appareil photo de l'intention.
3. La caméra va écrire l'image capturée à votre Uri.
4. Le lire en utilisant le contexte.getContentResolver().openInputStream().

Cette méthode de faire de votre code indépendant du retour à l'Uri dans l'intention puisque vous possédez de l'Uri. Aussi, cette charge galerie d'image pick trop avec de petites modifications.

Je vois que vous avez orientation du périphérique aussi des problèmes avec l'appareil photo. Cette (malheureusement) doit être traitée dans votre application une acquisition d'une image dans un post étape de traitement. J'ai souligné le code ci-dessous ainsi. Surtout, les questions de l'orientation qui s'est passé sur les appareils Samsung, où seule la caméra de capturer des images en mode paysage.

De créer une Uri de 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

Note : il est important que vous persistez mAttachmentUri de l'utilisation partagée des préférences ou de l'activité bundle avec onSaveInstanceState() sinon les Uri peuvent être perdues lorsque votre application est assassiné.

L'obtention de l'appareil photo objectif:

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 le fournisseur de contenu mise en oeuvre, vous pouvez utiliser un android FileProvider ou de mettre en œuvre un fournisseur de contenu comme ci-dessous. Ce fournisseur de contenu d'ouvrir un fichier dans vos applications conteneur pour l'application appareil photo à é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 ne la correction de l'image reçue de la caméra si nécessaire.

Ici est ce que je fais souvent dans mes projets, veuillez jeter un oeil. Espérons que cela aide!

Fragment de classe:

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

Utils classe:

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