Problème d'orientation de la caméra sous Android

100

Je construis une application qui utilise un appareil photo pour prendre des photos. Voici mon code source pour cela:

        File file = new File(Environment.getExternalStorageDirectory(),
            imageFileName);
    imageFilePath = file.getPath();
    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
    //Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
    startActivityForResult(intent, ACTIVITY_NATIVE_CAMERA_AQUIRE);

Sur la onActivityResult()méthode, j'utilise BitmapFactory.decodeStream()pour ramasser l'image.

Lorsque j'exécute mon application sur Nexus one, elle fonctionne bien. Mais lorsque je cours sur Samsung Galaxy S ou HTC Inspire 4G, la direction de l'image n'est pas correcte.

  • Capturez avec le mode portrait, l'image réelle (enregistrer sur la carte SD) tourne toujours à 90 degrés.

aperçu de l'image après la prise de vue image réelle sur la carte SD

Aperçu de l'image après la prise de vue --------- Image réelle sur la carte SD

  • Capturez avec le mode paysage, tout va bien.

Aperçu de l'image après la prise de vue Image réelle sur la carte SD

Aperçu de l'image après la prise de vue --------- Image réelle sur la carte SD

Nguyen Minh Binh
la source
1
setRotation (90) a fonctionné pour moi dans Samsung Galaxy Nexus, alors qu'il n'a pas fait pivoter l'image dans Xperia S.
StarDust
Est-ce que quelqu'un peut m'aider avec ça? J'ai le même problème stackoverflow.com/questions/28379130/…
Répondez ici stackoverflow.com/questions/14066038/…
Shirish Herwade

Réponses:

50

Il y a pas mal de sujets et de problèmes similaires ici. Puisque vous n'écrivez pas votre propre appareil photo, je pense que cela se résume à ceci:

certains appareils font pivoter l'image avant de l'enregistrer, tandis que d'autres ajoutent simplement la balise d'orientation dans les données exif de la photo.

Je recommanderais de vérifier les données exif de la photo et de rechercher en particulier

ExifInterface exif = new ExifInterface(SourceFileName);     //Since API Level 5
String exifOrientation = exif.getAttribute(ExifInterface.TAG_ORIENTATION);

Étant donné que la photo s'affiche correctement dans votre application, je ne sais pas où se trouve le problème, mais cela devrait certainement vous mettre sur la bonne voie!

ramz
la source
33
Cela ne semble pas fonctionner sur certains appareils, il renvoie 0 pour toutes les orientations .. Je sais que cela se produit sur Galaxy S Infuse et Sony Xperia Arc, et S II .. Ce qui est intéressant ici, c'est que lorsque ces mêmes images sont sélectionnées dans la galerie , le fournisseur de contenu a la valeur d'orientation appropriée. Des idées?
Tolga E
3
@Abhijit Oui, j'ai essayé de résoudre ce problème (ticket ouvert avec Android et ainsi de suite) Et je pense avoir trouvé une solution raisonnable pour gérer les deux téléphones avec des informations d'orientation appropriées et erronées. Consultez ma réponse détaillée que j'ai postée à ma propre question ici; stackoverflow.com/a/8864367/137404
Tolga E
1
@ramz j'ai essayé cette solution pour trouver. mais il renvoie 0 pour toutes les orientations. Avez-vous une idée de la raison pour laquelle il renvoie 0 pour toute l'orientation.
Dory
1
La raison pour laquelle cette solution ne fonctionne pas est parfois un mauvais "chemin" utilisé dans le constructeur ExifInterface. Surtout sur KitKat. Voir ici, comment trouver le bon chemin: stackoverflow.com/a/20559175/690777
peter.bartos
1
Il renvoie toujours 0 (ExifInterface.ORIENTATION_UNDEFINED) sur mon Samsung Galaxy S4 ...
valerybodak
28

Je viens de rencontrer le même problème et je l'ai utilisé pour corriger l'orientation:

public void fixOrientation() {
    if (mBitmap.getWidth() > mBitmap.getHeight()) {
        Matrix matrix = new Matrix();
        matrix.postRotate(90);
        mBitmap = Bitmap.createBitmap(mBitmap , 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), matrix, true);
    }
}

Si la largeur du Bitmap est supérieure à la hauteur, l'image renvoyée est en paysage, je la fais donc pivoter de 90 degrés.

J'espère que cela aide quelqu'un d'autre avec ce problème.


la source
18
Et si l'image était réellement prise en paysage? Votre code le fera toujours pivoter. Ce n'est pas une réponse à la question.
Wladimir Palant
1
Mon application force le portrait, donc ce n'est pas un problème. Je n'ai inclus ici qu'une solution alternative au problème.
5
Mais si l'application force le portrait, vous pouvez toujours prendre une photo de paysage (largeur> hauteur) et elle sera tournée ... C'est au moins ce que j'obtiens en réglant screenOrientation = "portrait" pour tout ... l'appareil photo peut toujours prendre du paysage photos.
Ixx
réponse complète et correcte présente ici stackoverflow.com/questions/6069122/…
Shirish Herwade
21

Deux choses sont nécessaires:

  1. L'aperçu de l'appareil photo doit être identique à votre rotation. Réglez ceci parcamera.setDisplayOrientation(result);

  2. Enregistrez l'image capturée comme aperçu de votre appareil photo. Faites-le via Camera.Parameters.

    int mRotation = getCameraDisplayOrientation();
    
    Camera.Parameters parameters = camera.getParameters();
    
    parameters.setRotation(mRotation); //set rotation to save the picture
    
    camera.setDisplayOrientation(result); //set the rotation for preview camera
    
    camera.setParameters(parameters);
    

J'espère que cela pourra aider.

Tran Khanh Tung
la source
Ça y est! Camera.parameters est vraiment pratique pour enregistrer des instantanés sans rendu dans un bitmap intermédiaire
rupps
Veuillez marquer ceci comme la réponse la plus simple! Cela fait le travail! Très heureux de cette solution facile
Kai Burghardt
Si cet extrait est pris tel parameters.setRotation(result)quel , nous pourrions simplement dire non?
Matt Logan
10
Cela suppose que vous utilisez directement la classe Camera, vous ne pouvez pas spécifier les mêmes options lorsque vous utilisez l'intention ACTION_IMAGE_CAPTURE.
rooftop
1
Qu'est-ce que result et getCameraDisplayOrientation ()?
venkat
10
            int rotate = 0;
            try {
                File imageFile = new File(sourcepath);
                ExifInterface exif = new ExifInterface(
                        imageFile.getAbsolutePath());
                int orientation = exif.getAttributeInt(
                        ExifInterface.TAG_ORIENTATION,
                        ExifInterface.ORIENTATION_NORMAL);

                switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_270:
                    rotate = 270;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    rotate = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_90:
                    rotate = 90;
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            Matrix matrix = new Matrix();
    matrix.postRotate(rotate);
    bitmap = Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
vigneron
la source
il serait utile d'avoir des explications sur ce que fait votre code, et comment il fait les choses différemment des autres réponses (la question est après tout déjà assez ancienne, et les autres réponses donc probablement assez mûres).
codeling le
7

Une autre option consiste à faire pivoter le bitmap dans l'écran de résultats comme ceci:

ImageView img=(ImageView)findViewById(R.id.ImageView01);
Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.refresh);
// Getting width & height of the given image.
int w = bmp.getWidth();
int h = bmp.getHeight();
// Setting post rotate to 90
Matrix mtx = new Matrix();
mtx.postRotate(90);
// Rotating Bitmap
Bitmap rotatedBMP = Bitmap.createBitmap(bmp, 0, 0, w, h, mtx, true);
BitmapDrawable bmd = new BitmapDrawable(rotatedBMP);

img.setImageDrawable(bmd);
PakitoV
la source
30
Cette approche ne fonctionnera pas, car elle fait également pivoter les images à partir d'appareils qui gèrent correctement l'orientation.
hanspeide
réponse complète et correcte présente ici stackoverflow.com/questions/6069122/…
Shirish Herwade
3

J'ai également ce type de problème pour certains appareils:

private void rotateImage(final String path) {

    Bitmap scaledBitmap = Bitmap.createScaledBitmap(Conasants.bm1, 1000,
            700, true);
    Bitmap rotatedBitmap = null;
    try {
        ExifInterface ei = new ExifInterface(path);
        int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_NORMAL);
        Matrix matrix = new Matrix();
        switch (orientation) {
        case ExifInterface.ORIENTATION_ROTATE_90:
            matrix.postRotate(90);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        case ExifInterface.ORIENTATION_ROTATE_180:
            matrix.postRotate(180);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        case ExifInterface.ORIENTATION_ROTATE_270:
            matrix.postRotate(270);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        default:
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        }
    } catch (Throwable e) {
        e.printStackTrace();
    }
    cropImage.setImageBitmap(rotatedBitmap);
    rotatedBitmap = null;
    Conasants.bm1 = null;
}
patel135
la source
1

Essayez de cette manière: Uri statique image_uri; Bitmap statique prise_image = null;

            image_uri=fileUri; // file where image has been saved

      taken_image=BitmapFactory.decodeFile(image_uri.getPath());
      try
        {
            ExifInterface exif = new ExifInterface(image_uri.getPath()); 

            int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);


            switch(orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 90);
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 180);

                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 270);

                    break;
                case ExifInterface.ORIENTATION_NORMAL:
                    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                    RotateBitmap(taken_image, 0);

                    break;
            }

        }
        catch (OutOfMemoryError e)
        {
            Toast.makeText(getActivity(),e+"\"memory exception occured\"",Toast.LENGTH_LONG).show();


        }



public Bitmap RotateBitmap(Bitmap source, float angle) {
      Matrix matrix = new Matrix();
      matrix.postRotate(angle);

      round_Image = source;
      round_Image = Bitmap.createBitmap(source, 0, 0, source.getWidth(),   source.getHeight(), matrix, true);


  return Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, true);

}

Sherin
la source
1

Plus besoin de vérifier les données exif de la photo. Allez-y doucement avec Glide .

Google nous a présenté une bibliothèque Image Loader pour Android développée par bumptech appelée Glide en tant que bibliothèque recommandée par Google. Il a été utilisé dans de nombreux projets open source Google jusqu'à présent, y compris l'application officielle Google I / O 2014.

Ex: Glide.with (contexte) .load (uri) .into (imageview);

Pour en savoir plus: https://github.com/bumptech/glide

S.Prapagorn
la source
1
public void setCameraPicOrientation(){
        int rotate = 0;
        try {
            File imageFile = new File(mCurrentPhotoPath);
            ExifInterface exif = new ExifInterface(
                    imageFile.getAbsolutePath());
            int orientation = exif.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);

            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_270:
                    rotate = 270;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    rotate = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_90:
                    rotate = 90;
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(rotate);
        int targetW = 640;
        int targetH = 640;

        /* Get the size of the image */
        BitmapFactory.Options bmOptions = new BitmapFactory.Options();
        bmOptions.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
        int photoW = bmOptions.outWidth;
        int photoH = bmOptions.outHeight;

        /* Figure out which way needs to be reduced less */
        int scaleFactor = 1;
        if ((targetW > 0) || (targetH > 0)) {
            scaleFactor = Math.min(photoW/targetW, photoH/targetH);
        }

        /* Set bitmap options to scale the image decode target */
        bmOptions.inJustDecodeBounds = false;
        bmOptions.inSampleSize = scaleFactor;
        bmOptions.inPurgeable = true;

        /* Decode the JPEG file into a Bitmap */
        Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
        bitmap= Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
            /* Associate the Bitmap to the ImageView */
      imageView.setImageBitmap(bitmap);
    }

J'espère que cela aidera !! Merci

Cher S
la source
0
    public static  int mOrientation =  1;

    OrientationEventListener myOrientationEventListener;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.takephoto);

        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);


        myOrientationEventListener
        = new OrientationEventListener(getApplicationContext()) {

            @Override
            public void onOrientationChanged(int o) {
                // TODO Auto-generated method stub
                if(!isTablet(getApplicationContext()))
                {
                    if(o<=285 && o>=80)
                        mOrientation = 2;
                    else
                        mOrientation = 1;
                }
                else
                {
                    if(o<=285 && o>=80)
                        mOrientation = 1;
                    else
                        mOrientation = 2;
                }

            }
        };

        myOrientationEventListener.enable();

    }



    public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }

}

J'espère que cela vous aidera, merci!

jagdish
la source
0

Rencontrez simplement le même problème ici, l'extrait de code ci-dessous fonctionne pour moi:

private static final String[] CONTENT_ORIENTATION = new String[] {
        MediaStore.Images.ImageColumns.ORIENTATION
};

static int getExifOrientation(ContentResolver contentResolver, Uri uri) {
    Cursor cursor = null;

    try {
        cursor = contentResolver.query(uri, CONTENT_ORIENTATION, null, null, null);
        if (cursor == null || !cursor.moveToFirst()) {
            return 0;
        }
        return cursor.getInt(0);
    } catch (RuntimeException ignored) {
        // If the orientation column doesn't exist, assume no rotation.
        return 0;
    } finally {
        if (cursor != null) {
            cursor.close();
        }
    }
}

j'espère que cela aide :)

Cloud Chen
la source
0

Essayez ceci dans le callback surfaceChanged:

Camera.Parameters parameters=mCamera.getParameters();
if(this.getResources().getConfiguration().orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){
    parameters.setRotation(90);
}else{
    parameters.setRotation(0);
}
mCamera.setParameters(parameters);
Manavendher
la source
0

// clic sur le bouton

btnCamera.setOnClickListener( new View.OnClickListener() {
        @Override
        public void onClick(View view) {

                try {
                    ContentValues values;
                    values = new ContentValues();
                    values.put(MediaStore.Images.Media.TITLE, "New Picture");
                    values.put(MediaStore.Images.Media.DESCRIPTION, "From your Camera");
                    imageUri = context.getContentResolver().insert(
                            MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
                    startActivityForResult(intent, CAMERA_REQUEST);
                }catch (Exception e){}

            });

// Méthode onActivityResult

   if (requestCode==CAMERA_REQUEST){
        try {
            if (imageUri!=null) {
                path = String.valueOf(new File(FilePath.getPath(context, imageUri)));
                   }  
        }catch (Exception e){
            toast("please try again "+e.getMessage());
            Log.e("image error",e.getMessage());
        }
    }

// créer un chemin de fichier de classe

classe publique FilePath {

public static String getPath(final Context context, final Uri uri) {

    // check here to KITKAT or new version
    final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;

    // DocumentProvider
    if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {

        // ExternalStorageProvider
        if (isExternalStorageDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/"
                        + split[1];
            }
        }
        // DownloadsProvider
        else if (isDownloadsDocument(uri)) {

            final String id = DocumentsContract.getDocumentId(uri);
            final Uri contentUri = ContentUris.withAppendedId(
                    Uri.parse("content://downloads/public_downloads"),
                    Long.valueOf(id));

            return getDataColumn(context, contentUri, null, null);
        }
        // MediaProvider
        else if (isMediaDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri = null;
            if ("image".equals(type)) {
                contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
            } else if ("video".equals(type)) {
                contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
            } else if ("audio".equals(type)) {
                contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            }

            final String selection = "_id=?";
            final String[] selectionArgs = new String[] { split[1] };

            return getDataColumn(context, contentUri, selection,
                    selectionArgs);
        }
    }
    // MediaStore (and general)
    else if ("content".equalsIgnoreCase(uri.getScheme())) {

        // Return the remote address
        if (isGooglePhotosUri(uri))
            return uri.getLastPathSegment();

        return getDataColumn(context, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

/**
 * Get the value of the data column for this Uri. This is useful for
 * MediaStore Uris, and other file-based ContentProviders.
 *
 * @param context
 *            The context.
 * @param uri
 *            The Uri to query.
 * @param selection
 *            (Optional) Filter used in the query.
 * @param selectionArgs
 *            (Optional) Selection arguments used in the query.
 * @return The value of the _data column, which is typically a file path.
 */
public static String getDataColumn(Context context, Uri uri,
                                   String selection, String[] selectionArgs) {

    Cursor cursor = null;
    final String column = "_data";
    final String[] projection = { column };

    try {
        cursor = context.getContentResolver().query(uri, projection,
                selection, selectionArgs, null);
        if (cursor != null && cursor.moveToFirst()) {
            final int index = cursor.getColumnIndexOrThrow(column);
            return cursor.getString(index);
        }
    } finally {
        if (cursor != null)
            cursor.close();
    }
    return null;
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is ExternalStorageProvider.
 */
public static boolean isExternalStorageDocument(Uri uri) {
    return "com.android.externalstorage.documents".equals(uri
            .getAuthority());
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is DownloadsProvider.
 */
public static boolean isDownloadsDocument(Uri uri) {
    return "com.android.providers.downloads.documents".equals(uri
            .getAuthority());
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is MediaProvider.
 */
public static boolean isMediaDocument(Uri uri) {
    return "com.android.providers.media.documents".equals(uri
            .getAuthority());
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is Google Photos.
 */
public static boolean isGooglePhotosUri(Uri uri) {
    return "com.google.android.apps.photos.content".equals(uri
            .getAuthority());
}

}

Pramila Rawat
la source
-1

Le code est fonctionnellement pour le paysage et le portrait @frontCameraID = variable obtenu la méthode classique pour montrer la caméra voulue

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    if(holder.getSurface() == null) {
        return;
    }
    try{
        camera.stopPreview();
    } catch (Exception e){
    }

    try{

        int orientation = getDisplayOrientation(frontCameraID);

        Camera.Parameters parameters = camera.getParameters();
        parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
        if (parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
        }

        parameters.setRotation(rotationPicture);
        camera.setParameters(parameters);
        camera.setDisplayOrientation(orientation);
        camera.startPreview();

    } catch (Exception e) {
        Log.i("ERROR", "Camera error changed: " + e.getMessage());
    }
}

Méthode pour obtenir l'orientation y rotation pour enregistrer l'image et afficher l'orientation @result = orientation sur la vue d'aperçu de la caméra @rotationPicture = rotation nécessaire pour enregistrer correctement l'image

private int getDisplayOrientation(int cameraId) {

    android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
    android.hardware.Camera.getCameraInfo(cameraId, info);
    int rotation = ((Activity) context).getWindowManager().getDefaultDisplay().getRotation();
    int degrees = 0;
    switch (rotation) {
        case Surface.ROTATION_0: degrees = 0; break;
        case Surface.ROTATION_90: degrees = 90; break;
        case Surface.ROTATION_180: degrees = 180; break;
        case Surface.ROTATION_270: degrees = 270; break;
    }

    int result;
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        result = (info.orientation + degrees) % 360;
        result = (360 - result) % 360;
        rotationPicture = (360 - result) % 360;
    } else {
        result = (info.orientation - degrees + 360) % 360;
        rotationPicture = result;
    }

    return result;
}

Quelqu'un a une question sur le code, veuillez me le dire.

Alex Zaraos
la source
-2

deux solutions One line utilisant Picasso et la bibliothèque glide

Après avoir passé beaucoup de temps avec de nombreuses solutions au problème de rotation d'image, j'ai finalement trouvé deux solutions simples. Nous n'avons pas besoin de faire de travaux supplémentaires. Picasso et Glide sont une bibliothèque très puissante pour la gestion des images dans votre application inclut. Il lit les données EXIF ​​de l'image et fait pivoter automatiquement les images.

Utilisation de la bibliothèque glide https://github.com/bumptech/glide

Glide.with(this).load("http url or sdcard url").into(imgageView);

Utilisation de la bibliothèque Picasso https://github.com/square/picasso

Picasso.with(context).load("http url or sdcard url").into(imageView);
Vigneswaran A
la source
Bienvenue à SO. Veuillez vous abstenir de demander des votes positifs: meta.stackexchange.com/questions/194061/…
2017