Tengo un error extraño en mi aplicación que hace que una actividad se reinicie en un bucle infinito cuando regreso de una aplicación de cámara, después de tomar una foto.

El flujo de la interfaz de usuario es así:

Actividad principal ->Aceptar actividad de foto -> en onCreate () abrir cámara con startActivityForResult ()Pantalla de la cámara -> tomar foto (o cancelar) -> regresar a Aceptar fotoLa pantalla Aceptar Foto se crea completa e inmediatamente se detiene y se recrea en un bucle infinito

Lo extraño es que solo sucede con algunas cámaras. En mi Nexus S con Jellybean, la cámara original se comporta correctamente, mientras que Camera Zoom FX causa este error. En mi tableta Archos G9 con ICS, tanto la cámara de archivo como el Zoom FX causan el error.

He comprobado el código paso a paso y no puedo encontrar el origen de la llamada de relanzamiento. Cuando detengo el depurador en la segunda (y posterior) llamada onCreate (), en la pila de llamadas hay una llamada ActivityThread.handleRelaunchActivity (). Su intención no tiene mucha información: la acción es nula, la clase es AcceptPhoto. El mFlags tiene el valor 603979776, que no sé cómo traducir en los indicadores de intención real.

Sin embargo, la rareza no se detiene aquí. En mi tableta, la primera vez que tomo la foto, la aplicación está bien. Si intento tomar una segunda foto, la pantalla se vuelve loca. Si, en lugar de tomar la imagen de los segundos, vuelvo a una pantalla anterior, todo está bien hasta que abra una nueva actividad. No importa desde dónde, si vuelvo hasta la actividad raíz y comienzo una nueva actividad, comenzará a parpadear.

Intentaré publicar algún código, pero sospecho que el error no está causado por mi código, pero estoy activando algo en el código de Android subyacente. Lo que espero es que tal vez alguien pueda indicarme la dirección correcta para encontrar una manera de solucionar este error. Cualquier cosa puede ser útil, ¡así que les agradezco cualquier idea!

El código utilizado para abrir la cámara (llamado en AcceptPhoto.onCreate (), usando una clase de utilidad):

private void openCamera(Context context) {
    Intent pictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    File tempFile = getTempFile(context);
    try {
        if (tempFile != null) {

            pictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(tempFile));

            ((Activity) context).startActivityForResult(pictureIntent, GET_ITEM_PHOTO);
        } else {
            Toast.makeText(context, "Could not create temp file", Toast.LENGTH_SHORT).show();
        }
    } catch (Exception e) {
        Toast.makeText(context, "Error opening camera " + e.getMessage(), Toast.LENGTH_LONG).show();
        e.printStackTrace();
    }
}

El código utilizado para mostrar la imagen, llamado en AcceptPhoto.onActivityResult ():

private void displayPhoto() {
    if (cameraUtils == null) {
        cameraUtils = new CameraUtil();
    }
    previewImageView.setImageDrawable(null);
    File tempFile = cameraUtils.getTempFile(this);

    int rotation = 0;
    try {
        ExifInterface exif = new ExifInterface(tempFile.getPath());
        String orientation = exif.getAttribute(ExifInterface.TAG_ORIENTATION);
        Log.i("SPRING", "Photo orientation " + orientation);
        rotation = getBitmapRotation(Integer.valueOf(orientation));
        Log.i("SPRING", "The image needs to be rotated by " + (rotation) + " degrees");
    } catch (IOException e1) {
        e1.printStackTrace();
    }
    try {
        previewBitmap = BitmapEncoderUtil.loadPrescaledBitmap(tempFile);
        if (rotation != 0) {

            Matrix rotationMatrix = new Matrix();
            rotationMatrix.postRotate(rotation);

            int w = previewBitmap.getWidth();
            int h = previewBitmap.getHeight();

            Bitmap rotatedBitmap = Bitmap.createBitmap(previewBitmap, 0, 0, w, h, rotationMatrix, false);

            previewBitmap = rotatedBitmap;
        }
        previewImageView.setImageBitmap(previewBitmap);
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

Método utilizado en la clase de utilidad para crear / recuperar el archivo donde la cámara guarda la foto:

public File getTempFile(Context context) {

    String externalStorageStateString = Environment.getExternalStorageState();
    File cacheDirectory;
    // try to save in external storage
    if (externalStorageStateString.equals(Environment.MEDIA_MOUNTED)) {
        cacheDirectory = context.getExternalCacheDir();
    } else {
        // save in internal storage
        cacheDirectory = context.getCacheDir();
    }
    File tempSnapshotFile = new File(cacheDirectory, MissionOtherActivity.ITEM_SNAPSHOT_PATH);

    // make sure the file exists, possible fix for the camera bug
    try {
        if (tempSnapshotFile.exists() == false) {
            tempSnapshotFile.getParentFile().mkdirs();
            tempSnapshotFile.createNewFile();
        }

    } catch (IOException e) {
        Log.e("SPRING", "Could not create file.", e);
    }
    return tempSnapshotFile;
}