Eu tenho um bug estranho no meu aplicativo que faz com que uma atividade seja reiniciada em um loop infinito quando eu estou voltando de um aplicativo de câmera, depois de tirar uma foto.

O fluxo da interface do usuário é assim:

Atividade Principal ->Aceitar atividade de foto -> em onCreate () abrir a câmera com startActivityForResult ()Tela da câmera -> tirar foto (ou cancelar) -> voltar para Aceitar fotoA tela Aceitar foto é criada completamente e imediatamente interrompida e recriada em um loop infinito

A parte estranha é que isso só acontece para algumas câmeras. No meu Nexus S executando o Jellybean, a câmera de estoque se comporta corretamente, enquanto o Camera Zoom FX causa esse bug. No meu tablet Archos G9 rodando o ICS, tanto a câmera como o Zoom FX causam o bug.

Verifiquei o código passo a passo e não consigo encontrar a origem da nova chamada. Quando estou parando o depurador na segunda (e subseqüente) chamada onCreate (), na pilha de chamadas há uma chamada ActivityThread.handleRelaunchActivity (). Sua intenção não tem muita informação: a ação é nula, a classe é AcceptPhoto. O mFlags tem o valor 603979776, que eu não sei traduzir para os flags de intenção reais.

A esquisitice não para aqui, no entanto. No meu tablet, a primeira vez que tiro a foto, o aplicativo está bem. Se eu tentar tirar uma segunda foto, a tela fica louca. Se, em vez de tirar a foto do segundo, eu voltar a uma tela anterior, tudo bem até eu abrir uma nova atividade. Não importa de onde, se eu retornar todo o caminho para a atividade de raiz e começar uma nova atividade, ela começa a piscar.

Vou tentar postar algum código, mas suspeito que o bug não é causado pelo meu código, mas estou acionando algo no código subjacente do Android. O que eu espero é que talvez alguém possa me apontar na direção correta para encontrar uma maneira de contornar esse bug. Qualquer coisa pode ser útil, então eu agradeço por qualquer ideia!

O código usado para abrir a câmera (chamado em AcceptPhoto.onCreate (), usando uma classe de utilitário):

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

O código usado para exibir a imagem, chamado em 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 usado na classe de utilitário para criar / recuperar o arquivo em que a câmera salva a 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;
}