Android'de kamera yönü sorunu


100

Fotoğraf çekmek için kamera kullanan bir uygulama geliştiriyorum. İşte bunu yapmak için kaynak kodum:

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

Açık onActivityResult()yöntemle, kullandığım BitmapFactory.decodeStream()pikap görüntüyü.

Uygulamamı Nexus one'da çalıştırdığımda iyi çalışıyor. Ancak Samsung Galaxy S veya HTC Inspire 4G'de çalıştırdığımda görüntünün yönü doğru değil.

  • Portre modu ile çekim yapın, gerçek görüntü (SD karta kaydedin) her zaman 90 derece döner.

çekimden sonra görüntü önizlemesi SD kartta gerçek görüntü

Çekimden sonra görüntü önizleme --------- SD kartta gerçek görüntü

  • Manzara moduyla çekim yapın, her şey iyidir.

Çekimden sonra görüntü önizlemesi SD kartta gerçek görüntü

Çekimden sonra görüntü önizleme --------- SD kartta gerçek görüntü


1
setRotation (90), Xperia S'de görüntüyü döndürmediği halde Samsung Galaxy Nexus'ta benim için işe yaradı.
StarDust

kimse bana bu konuda yardımcı olabilir mi? bende aynı sorun var stackoverflow.com/questions/28379130/…



Yanıtlar:


50

Burada oldukça benzer konular ve sorunlar var. Kendi kameranı yazmadığına göre, sanırım bu şuna indirgeniyor:

bazı cihazlar görüntüyü kaydetmeden önce döndürür, diğerleri ise fotoğrafın exif verilerine yön etiketini ekler.

Fotoğrafın exif verilerini kontrol etmenizi ve özellikle

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

Fotoğraf uygulamanızda doğru şekilde görüntülendiğinden, sorunun nerede olduğundan emin değilim, ancak bu kesinlikle sizi doğru yola yönlendirecektir!


33
Bu, bazı cihazlarda işe yaramıyor gibi görünüyor, tüm yönler için 0 döndürüyor .. Bunun Galaxy S Infuse ve Sony Xperia Arc ve S II'de olduğunu biliyorum .. Burada ilginç olan, aynı görüntülerin galeriden seçilmesidir. , içerik sağlayıcı uygun yönlendirme değerine sahiptir .. Herhangi bir fikir?
Tolga E

3
@Abhijit Evet Bunu çözmeye çalıştım (Android vb. İle açılmış bilet) Ve her iki telefonu da doğru ve hatalı yönlendirme bilgileriyle ele almak için makul bir çözüm bulduğumu düşünüyorum. Kendi soruma gönderdiğim ayrıntılı cevabıma buradan göz atın; stackoverflow.com/a/8864367/137404
Tolga E

1
@ramz Bu çözümü bulmayı denedim. ancak tüm yönler için 0 döndürüyor. Tüm oryantasyon için neden 0 döndürdüğüne dair bir fikriniz var mı?
Dory

1
Bu çözümün çalışmamasının nedeni bazen ExifInterface yapıcısında kullanılan yanlış bir "yol" dur. Çoğunlukla KitKat'ta. Doğru yolu nasıl elde edeceğinizi buradan öğrenin: stackoverflow.com/a/20559175/690777
peter.bartos

1
Samsung Galaxy S4'ümde her zaman 0 (ExifInterface.ORIENTATION_UNDEFINED) döndürür ...
valerybodak

28

Aynı sorunla az önce karşılaştım ve bunu yönlendirmeyi düzeltmek için kullandım:

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

Bitmap'in genişliği yükseklikten büyükse, döndürülen görüntü yataydır, bu yüzden onu 90 derece döndürüyorum.

Umarım bu konuda başkalarına yardımcı olur.


18
Ya görüntü gerçekten manzarada çekilmişse ? Kodunuz yine de döndürecektir. Bu sorunun cevabı değil.
Wladimir Palant 01

1
Uygulamam portreyi zorluyor, bu yüzden bu bir sorun değil. Buraya sadece soruna alternatif bir çözüm ekledim.

5
Ancak uygulama portreyi zorlarsa, yine de yatay bir resim çekebilirsiniz (genişlik> yükseklik) ve döndürülür ... En azından her şey için screenOrientation = "portre" ayarını alıyorum ... kamera yine de manzara çekebilir resimler.
Ixx

tam ve doğru cevap burada mevcut stackoverflow.com/questions/6069122/…
Shirish Herwade

21

İhtiyaç duyulan iki şey var:

  1. Kamera önizlemesi, rotasyonunuzla aynı olmalıdır. Bunu şu şekilde ayarlacamera.setDisplayOrientation(result);

  2. Yakalanan resmi kamera önizlemeniz olarak kaydedin. Bunu şu yolla yapın 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);
    

Umarım yardımcı olur.


budur! Camera.parameters anlık görüntüleri ara bitmap'e dönüştürmeden kaydetmek için gerçekten kullanışlıdır
2014

Lütfen bunu en kolay cevap olarak işaretleyin! Bu işi yap! Bu kolay çözümden çok memnunum
Kai Burghardt

Bu pasaj olduğu gibi alınırsa parameters.setRotation(result), hayır diyebiliriz.
Matt Logan

10
Bu, doğrudan Camera sınıfını kullandığınızı varsayar, ACTION_IMAGE_CAPTURE amacını kullanırken aynı seçenekleri belirleyemezsiniz.
çatı katında

1
Result ve getCameraDisplayOrientation () nedir?
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);

Kodunuzun ne yaptığını ve diğer yanıtlardan farklı olarak nasıl şeyler yaptığını açıklamak faydalı olacaktır (sonuçta soru zaten oldukça eskidir ve diğer yanıtlar bu nedenle muhtemelen oldukça olgunlaşmıştır).
kodlama

7

Diğer bir seçenek, sonuç ekranındaki bitmap'i şu şekilde döndürmektir:

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

30
Bu yaklaşım, aynı zamanda yönlendirmeyi düzgün bir şekilde gerçekleştiren cihazlardan görüntüleri de döndürdüğü için işe yaramaz.
hanspeide

tam ve doğru cevap burada mevcut stackoverflow.com/questions/6069122/…
Shirish Herwade

3

Bazı cihazlar için de aynı problemi yaşıyorum:

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

1

Şu yolu deneyin: statik Uri image_uri; statik Bitmap taken_image = boş;

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

}


1

Artık fotoğrafın exif verilerini kontrol etmeye gerek yok. Glide ile sakin olun .

Google, Google tarafından önerilen bir kitaplık olan Glide adlı bumptech tarafından geliştirilen Android için bir Image Loader Kitaplığı'nı bize tanıttı . Şu ana kadar Google I / O 2014 resmi uygulaması da dahil olmak üzere birçok Google açık kaynak projesinde kullanılmıştır.

Ör: Glide.with (bağlam) .load (uri) .into (görüntü görünümü);

Daha fazlası için: https://github.com/bumptech/glide


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

Umarım bu yardımcı olur !! Teşekkürler


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

}

Umarım bu yardımcı olur.


0

Sadece burada aynı sorunla karşılaşın, aşağıdaki kod parçası benim için çalışıyor:

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

umarım bu yardımcı olur :)


0

Bunu SurfaceChanged geri aramada deneyin:

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

0

// düğme tıklaması

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){}

            });

// onActivityResult yöntemi

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

// bir sınıf dosya yolu oluştur

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

}


-1

Kod işlevsel olarak manzara ve portre içindir @frontCameraID = değişken, şov kamerasının istenen klasik yöntemini aldı

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

Resmi kaydetmek için yön y döndürme yöntemi ve görüntü yönelimi @ sonuç = kameranın önizleme görünümündeki yönlendirme @ rotationPicture = resmi doğru şekilde kaydetmek için döndürme gerekli

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

Kodla ilgili bir soru, lütfen bana söyleyin.


-2

Picasso ve glide kitaplığını kullanan iki tek satırlık çözüm

Görüntü döndürme sorunu için birçok çözümle çok zaman geçirdikten sonra nihayet iki basit çözüm buldum. Herhangi bir ek çalışma yapmamıza gerek yok. Picasso ve Glide, uygulamanızdaki görüntüleri işlemek için çok güçlü bir kitaplıktır. Görüntü EXIF ​​verilerini okuyacak ve görüntüleri otomatik olarak döndürecektir.

Kayma kitaplığını kullanma https://github.com/bumptech/glide

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

Picasso kitaplığını kullanma https://github.com/square/picasso

Picasso.with(context).load("http url or sdcard url").into(imageView);

SO'ya hoş geldiniz. Lütfen olumlu oy istemekten kaçının: meta.stackexchange.com/questions/194061/…
Ocak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.