Solucionado (ver solução)
Solucionado
(ver solução)
3
respostas

Solução para imagem virada não funciona!

Não sei é por estar usando versões mais recentes, mas quando eu implemento a solução da classe "CarregadorDeFoto" sugerida no post do blog com relação às imagens viradas, o compilador aponta muitos erros como Unhandled Exception e Missing Return.. coisas do tipo. No fim, o código do carregador de arquivos que compila é o seguinte:

public class CarregadorDeFoto {

        public static Bitmap carrega(String caminhoFoto) {
            ExifInterface exif = null;
            try {
                exif = new ExifInterface(caminhoFoto);
            } catch (IOException e) {
                e.printStackTrace();
            }
            String orientacao = exif.getAttribute(ExifInterface.TAG_ORIENTATION);
            int codigoOrientacao = Integer.parseInt(orientacao);

            switch (codigoOrientacao) {
                case ExifInterface.ORIENTATION_NORMAL:
                    return abreFotoERotaciona(caminhoFoto, 0);
                case ExifInterface.ORIENTATION_ROTATE_90:
                    return abreFotoERotaciona(caminhoFoto, 90);
                case ExifInterface.ORIENTATION_ROTATE_180:
                    return abreFotoERotaciona(caminhoFoto, 180);
                case ExifInterface.ORIENTATION_ROTATE_270:
                    return abreFotoERotaciona(caminhoFoto, 270);
            }
            return null;
        }

        private static Bitmap abreFotoERotaciona(String caminhoFoto, int angulo) {
            // Abre o bitmap a partir do caminho da foto
            Bitmap bitmap = BitmapFactory.decodeFile(caminhoFoto);

            // Prepara a operação de rotação com o ângulo escolhido
            Matrix matrix = new Matrix();
            matrix.postRotate(angulo);

            // Cria um novo bitmap a partir do original já com a rotação aplicada
            return Bitmap.createBitmap(bitmap, 0, 0,
                    bitmap.getWidth(), bitmap.getHeight(),
                    matrix, true);
        }
}

Com detalhe para o try...catch que não havia:

  try {
                exif = new ExifInterface(caminhoFoto);
            } catch (IOException e) {
                e.printStackTrace();
            }

Também para o retorno:

case ExifInterface.ORIENTATION_ROTATE_270:
                    return abreFotoERotaciona(caminhoFoto, 270);
            }
            return null;
        }

E por fim, tornando o metodo "abreFotoERotaciona" estatico:

 private static Bitmap abreFotoERotaciona(String caminhoFoto, int angulo) {
            // Abre o bitmap a partir do caminho da foto
            Bitmap bitmap = BitmapFactory.decodeFile(caminhoFoto);
3 respostas

Ola, tudo bom Douglas

Recentemente utilizei este mesmo exemplo, em uma aplicação que estava desenvolvendo.

Tive problemas com alguns versões de Android mais antigas

O meu problema era que o dispositivo não retornava a orientação da foto. Debugando percebi que o retorno era nulo (apenas nessas versões)...

String orientacao = exif.getAttribute(ExifInterface.TAG_ORIENTATION);

Uma solução que encontrei, foi ter um retorno default

 switch (codigoOrientacao) {
                case ExifInterface.ORIENTATION_NORMAL:
                    return rotacionadoBitmap(caminhoFoto, 0);
                case ExifInterface.ORIENTATION_ROTATE_90:
                    return rotacionadoBitmap(caminhoFoto, 90);
                case ExifInterface.ORIENTATION_ROTATE_180:
                    return rotacionadoBitmap(caminhoFoto, 180);
                case ExifInterface.ORIENTATION_ROTATE_270:
                    return rotacionadoBitmap(caminhoFoto, 270);
                default:
                    return rotacionadoBitmap(caminhoFoto, 0);
            }

Verifica se funciona pra você, abç

Também tive o mesmo problema, ele acusa que o carrega está sem retorno e que o método abreFotoERotaciona() precisa ser estático.Douglas, eu coloquei o default: return abreFotoERotaciona(caminhoFoto....) no meu código, isso é suficiente ou também tem que colocar o Try{ } Catch() {} para resolver o problema?

public class CarregadorDeFoto {

public static Bitmap carrega(String caminhoFoto) {

    ExifInterface exif = new ExifInterface(caminhoFoto);
    String orientacao = exif.getAttribute(ExifInterface.TAG_ORIENTATION);
    int codigoOrientacao = Integer.parseInt(orientacao);

        switch (codigoOrientacao) {
            case ExifInterface.ORIENTATION_NORMAL:
                return abreFotoERotaciona(caminhoFoto, 0);
            case ExifInterface.ORIENTATION_ROTATE_90:
                return abreFotoERotaciona(caminhoFoto, 90);
            case ExifInterface.ORIENTATION_ROTATE_180:
                return abreFotoERotaciona(caminhoFoto, 180);
            case ExifInterface.ORIENTATION_ROTATE_270:
                return abreFotoERotaciona(caminhoFoto, 270);
            default:
                return abreFotoERotaciona(caminhoFoto, 0);

        }

}

private static Bitmap abreFotoERotaciona(String caminhoFoto, int angulo) {
    // Abre o bitmap a partir do caminho da foto
    Bitmap bitmap = BitmapFactory.decodeFile(caminhoFoto);

    // Prepara a operação de rotação com o ângulo escolhido
    Matrix matrix = new Matrix();
    matrix.postRotate(angulo);

    // Cria um novo bitmap a partir do original já com a rotação aplicada
    return Bitmap.createBitmap(bitmap, 0, 0,
            bitmap.getWidth(), bitmap.getHeight(),
            matrix, true);
}
solução!

Ola Antonio

Se o seu método carrega, não tivesse o default:, ai realmente ele poderia ficar sem um retorno, mas com este bloco, não existe esta possibilidade. (isso pra sua implementação do método, ok)

O seu método abreFotoERotaciona, esta sendo chamado em um contexto estático, por isto, precisa ser estático.

Já o Try{ } Catch() {} é necessário, pois, ExifInterfacepode lançar uma IOException.

A minha implementação ficou assim:

 public static Bitmap devolveBitmapRotacionado(String caminhoFoto) {
        try {
            ExifInterface exif = new ExifInterface(caminhoFoto);

            String orientacao = exif.getAttribute(ExifInterface.TAG_ORIENTATION);
            int codigoOrientacao = Integer.parseInt(orientacao);

            switch (codigoOrientacao) {
                case ExifInterface.ORIENTATION_NORMAL:
                    return rotacionadoBitmap(caminhoFoto, 0);
                case ExifInterface.ORIENTATION_ROTATE_90:
                    return rotacionadoBitmap(caminhoFoto, 90);
                case ExifInterface.ORIENTATION_ROTATE_180:
                    return rotacionadoBitmap(caminhoFoto, 180);
                case ExifInterface.ORIENTATION_ROTATE_270:
                    return rotacionadoBitmap(caminhoFoto, 270);
                default:
                    return rotacionadoBitmap(caminhoFoto, 0);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
 private static Bitmap rotacionadoBitmap(String caminhoFoto, int angulo) {
        if (caminhoFoto != null) {

            // Abre o bitmap a partir do caminho da foto
            Bitmap bitmap = devolveBitmap(caminhoFoto);

            // Prepara a operação de rotação com o ângulo escolhido
            Matrix matrix = new Matrix();
            matrix.postRotate(angulo);

            // Cria um novo bitmap a partir do original já com a rotação aplicada
            return Bitmap.createBitmap(bitmap, 0, 0,
                    bitmap.getWidth(), bitmap.getHeight(),
                    matrix, true);
        }

        return null;
    }

Vê se te ajuda, e posta o resultado aqui beleza

abç