method - picasso android que es

Android Picasso auto gira imagen

Question

Estoy usando Picasso para cargar imágenes de la web en mi aplicación. Me he dado cuenta de que algunas imágenes se muestran rotadas 90 grados, aunque cuando abro la imagen en mi navegador, la veo en la posición correcta. Supongo que estas imágenes tienen datos EXIF. ¿Hay alguna forma de indicar a Picasso que ignore EXIF?

Answer 1

¿Puedes publicar la imagen que estás usando? porque como dice este thread , la orientación exif para las imágenes cargadas desde la web se ignora (solo el proveedor de contenido y los archivos locales).

También trato de mostrar esta image en picasso 2.5.2, la orientación real de la imagen está orientada hacia el lado derecho (el código inferior de la imagen está orientado hacia la derecha). La orientación exif es de 90 grados en el sentido de las agujas del reloj. Intente abrirlo en cromo (el cromo respeta la rotación de exif), la imagen se verá hacia abajo (el código de abajo en la imagen está hacia abajo).

Answer 2

Como sabemos, Picasso admite EXIF ​​desde el almacenamiento local, esto se realiza a través de las utilidades internas de Android. Proporcionar la misma funcionalidad no se puede hacer fácilmente debido a la capacidad de usar bibliotecas de carga HTTP personalizadas. Mi solución es simple: debemos anular el almacenamiento en caché y aplicar la rotación Exif antes de que el elemento se almacene en caché.

    OkHttpClient client = new OkHttpClient.Builder()
        .addNetworkInterceptor(chain -> {
            Response originalResponse = chain.proceed(chain.request());
            byte[] body = originalResponse.body().bytes();
            ResponseBody newBody = ResponseBody
                .create(originalResponse.body().contentType(), ImageUtils.processImage(body));
            return originalResponse.newBuilder().body(newBody).build();
        })
        .cache(cache)
        .build();

Aquí agregamos NetworkInterceptor que puede transformar la solicitud y la respuesta antes de que se almacene en caché.

public class ImageUtils {

    public static byte[] processImage(byte[] originalImg) {
        int orientation = Exif.getOrientation(originalImg);
        if (orientation != 0) {
            Bitmap bmp = BitmapFactory.decodeByteArray(originalImg, 0, originalImg.length);
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            rotateImage(orientation, bmp).compress(Bitmap.CompressFormat.PNG, 100, stream);

            return stream.toByteArray();
        }
        return originalImg;
    }

    private static Bitmap rotateImage(int angle, Bitmap bitmapSrc) {
        Matrix matrix = new Matrix();
        matrix.postRotate(angle);
        return Bitmap.createBitmap(bitmapSrc, 0, 0,
                bitmapSrc.getWidth(), bitmapSrc.getHeight(), matrix, true);
    }
}

Transformación Exif:

public class Exif {
    private static final String TAG = "Exif";

    // Returns the degrees in clockwise. Values are 0, 90, 180, or 270.
    public static int getOrientation(byte[] jpeg) {
        if (jpeg == null) {
            return 0;
        }

        int offset = 0;
        int length = 0;

        // ISO/IEC 10918-1:1993(E)
        while (offset + 3 < jpeg.length && (jpeg[offset++] & 0xFF) == 0xFF) {
            int marker = jpeg[offset] & 0xFF;

            // Check if the marker is a padding.
            if (marker == 0xFF) {
                continue;
            }
            offset++;

            // Check if the marker is SOI or TEM.
            if (marker == 0xD8 || marker == 0x01) {
                continue;
            }
            // Check if the marker is EOI or SOS.
            if (marker == 0xD9 || marker == 0xDA) {
                break;
            }

            // Get the length and check if it is reasonable.
            length = pack(jpeg, offset, 2, false);
            if (length < 2 || offset + length > jpeg.length) {
                Log.e(TAG, "Invalid length");
                return 0;
            }

            // Break if the marker is EXIF in APP1.
            if (marker == 0xE1 && length >= 8 &&
                    pack(jpeg, offset + 2, 4, false) == 0x45786966 &&
                    pack(jpeg, offset + 6, 2, false) == 0) {
                offset += 8;
                length -= 8;
                break;
            }

            // Skip other markers.
            offset += length;
            length = 0;
        }

        // JEITA CP-3451 Exif Version 2.2
        if (length > 8) {
            // Identify the byte order.
            int tag = pack(jpeg, offset, 4, false);
            if (tag != 0x49492A00 && tag != 0x4D4D002A) {
                Log.e(TAG, "Invalid byte order");
                return 0;
            }
            boolean littleEndian = (tag == 0x49492A00);

            // Get the offset and check if it is reasonable.
            int count = pack(jpeg, offset + 4, 4, littleEndian) + 2;
            if (count < 10 || count > length) {
                Log.e(TAG, "Invalid offset");
                return 0;
            }
            offset += count;
            length -= count;

            // Get the count and go through all the elements.
            count = pack(jpeg, offset - 2, 2, littleEndian);
            while (count-- > 0 && length >= 12) {
                // Get the tag and check if it is orientation.
                tag = pack(jpeg, offset, 2, littleEndian);
                if (tag == 0x0112) {
                    // We do not really care about type and count, do we?
                    int orientation = pack(jpeg, offset + 8, 2, littleEndian);
                    switch (orientation) {
                        case 1:
                            return 0;
                        case 3:
                            return 180;
                        case 6:
                            return 90;
                        case 8:
                            return 270;
                    }
                    Log.i(TAG, "Unsupported orientation");
                    return 0;
                }
                offset += 12;
                length -= 12;
            }
        }

        Log.i(TAG, "Orientation not found");
        return 0;
    }

    private static int pack(byte[] bytes, int offset, int length,
                            boolean littleEndian) {
        int step = 1;
        if (littleEndian) {
            offset += length - 1;
            step = -1;
        }

        int value = 0;
        while (length-- > 0) {
            value = (value << 8) | (bytes[offset] & 0xFF);
            offset += step;
        }
        return value;
    }
}

Esta solución es experimental y debe ser probada para detectar fugas y probablemente mejorada. En la mayoría de los casos, los dispositivos Samsung e iO devuelven una rotación de 90 DEG y esta solución funciona. Otros casos también deben ser examinados.