Sự cố hướng camera trong Android


100

Tôi đang xây dựng một ứng dụng sử dụng máy ảnh để chụp ảnh. Đây là mã nguồn của tôi để làm điều này:

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

Trên onActivityResult()phương pháp, tôi sử dụng BitmapFactory.decodeStream()để lấy hình ảnh.

Khi tôi chạy ứng dụng của mình trên Nexus một, nó chạy tốt. Nhưng khi tôi chạy trên Samsung Galaxy S hoặc HTC Inspire 4G, hướng của hình ảnh không chính xác.

  • Chụp với chế độ chân dung, ảnh thật (lưu trên thẻ SD) luôn xoay 90 độ.

xem trước hình ảnh sau khi chụp hình ảnh thực tế trên thẻ SD

Xem trước hình ảnh sau khi chụp --------- Hình ảnh thực trên thẻ SD

  • Chụp ở chế độ ngang, tất cả mọi thứ đều tốt.

Xem trước hình ảnh sau khi chụp Hình ảnh thực tế trên thẻ SD

Xem trước hình ảnh sau khi chụp --------- Hình ảnh thực trên thẻ SD


1
setRotation (90) đã hoạt động với tôi trong Samsung Galaxy Nexus, trong khi nó không xoay hình ảnh trong Xperia S.
StarDust

bất cứ ai có thể giúp tôi với điều này? tôi gặp vấn đề tương tự stackoverflow.com/questions/28379130/…



Câu trả lời:


50

Có khá nhiều chủ đề và vấn đề tương tự xung quanh đây. Vì bạn không viết máy ảnh của riêng mình, nên tôi nghĩ nó tóm tắt ở điều này:

một số thiết bị xoay hình ảnh trước khi lưu, trong khi những thiết bị khác chỉ cần thêm thẻ định hướng trong dữ liệu exif của ảnh.

Tôi khuyên bạn nên kiểm tra dữ liệu exif của ảnh và đặc biệt tìm kiếm

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

Vì ảnh đang hiển thị chính xác trong ứng dụng của bạn, tôi không chắc vấn đề nằm ở đâu, nhưng điều này chắc chắn sẽ giúp bạn đi đúng hướng!


33
Điều này dường như không hoạt động trên một số thiết bị, nó trả về 0 cho tất cả các hướng .. Tôi biết nó xảy ra trên Galaxy S Infuse và Sony Xperia Arc và S II .. Điều thú vị ở đây là khi những hình ảnh giống nhau này được chọn từ thư viện , nhà cung cấp nội dung có giá trị định hướng thích hợp .. Bất kỳ ý tưởng nào?
Tolga E

3
@Abhijit Có, tôi đã cố gắng giải quyết vấn đề này (đã mở vé với Android, v.v.) Và tôi nghĩ rằng tôi đã tìm ra giải pháp hợp lý để xử lý cả hai điện thoại có thông tin định hướng phù hợp và bị lỗi. Kiểm tra câu trả lời chi tiết của tôi mà tôi đã đăng cho câu hỏi của chính mình tại đây; stackoverflow.com/a/8864367/137404
Tolga E

1
@ramz Tôi đã thử giải pháp này để tìm. nhưng nó đang trả về 0 cho tất cả các hướng. Bạn có biết tại sao nó trả về 0 cho tất cả các hướng không.
Dory

1
Lý do giải pháp này không hoạt động đôi khi là một "đường dẫn" sai được sử dụng trong hàm tạo ExifInterface. Chủ yếu là trên KitKat. Xem ở đây, làm thế nào để có được con đường đúng đắn: stackoverflow.com/a/20559175/690777
peter.bartos

1
Nó luôn trả về 0 (ExifInterface.ORIENTATION_UNDEFINED) trên Samsung Galaxy S4 của tôi ...
valerybodak 23/02/15

28

Tôi vừa gặp sự cố tương tự và sử dụng điều này để sửa hướng:

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

Nếu chiều rộng của Bitmap lớn hơn chiều cao, hình ảnh trả về sẽ ở dạng ngang, vì vậy tôi xoay nó 90 độ.

Hy vọng nó sẽ giúp bất cứ ai khác với vấn đề này.


18
Điều gì sẽ xảy ra nếu hình ảnh thực sự được chụp ở chế độ ngang? Mã của bạn sẽ vẫn xoay nó. Đây không phải là câu trả lời cho câu hỏi.
Wladimir Palant

1
Ứng dụng của tôi buộc dọc, vì vậy đó không phải là vấn đề. Tôi chỉ bao gồm điều này ở đây một giải pháp thay thế cho vấn đề.

5
Nhưng nếu ứng dụng ép chân dung, bạn vẫn có thể chụp ảnh ngang (chiều rộng> chiều cao) và nó sẽ được xoay ... Đó là ít nhất những gì tôi đang thiết lập screenOrientation = "chân dung" cho mọi thứ ... máy ảnh vẫn có thể chụp phong cảnh bức ảnh.
Ixx

đầy đủ và chính xác câu trả lời hiện diện ở đây stackoverflow.com/questions/6069122/...
Shirish Herwade

21

Có hai điều cần thiết:

  1. Xem trước máy ảnh cần giống như xoay của bạn. Đặt cái này bằngcamera.setDisplayOrientation(result);

  2. Lưu ảnh đã chụp làm bản xem trước máy ảnh của bạn. Làm điều này thông qua 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);

Hy vọng rằng sẽ giúp.


đây là nó! Camera.parameters thực sự thuận tiện để lưu ảnh chụp nhanh mà không cần kết xuất thành bitmap trung gian
rupps

Hãy đánh dấu đây là câu trả lời dễ nhất! Điều này thực hiện công việc! Rất hài lòng về giải pháp dễ dàng này
Kai Burghardt

Nếu đoạn mã này được giữ nguyên như vậy, chúng tôi chỉ có thể nói parameters.setRotation(result), không?
Matt Logan

10
Điều này giả sử bạn đang sử dụng trực tiếp lớp Máy ảnh, bạn không thể chỉ định các tùy chọn tương tự khi bạn đang sử dụng ý định ACTION_IMAGE_CAPTURE.
tầng mái

1
Kết quả và getCameraDisplayOrientation () là gì?
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);

Sẽ rất hữu ích nếu có một số lời giải thích mã của bạn đang làm gì và nó hoạt động như thế nào khác với các câu trả lời khác (câu hỏi cuối cùng đã khá cũ và các câu trả lời khác do đó có thể khá chín chắn).
codeling

7

Một tùy chọn khác là xoay bitmap trong màn hình kết quả như sau:

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
Cách tiếp cận này sẽ không hoạt động, vì nó cũng xoay hình ảnh từ các thiết bị xử lý hướng đúng cách.
hanspeide

đầy đủ và chính xác câu trả lời hiện diện ở đây stackoverflow.com/questions/6069122/...
Shirish Herwade

3

Tôi cũng gặp phải loại vấn đề tương tự đối với một số thiết bị:

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

Hãy thử cách này: static Uri image_uri; Bitmap tĩnh taken_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);

}


1

Không cần kiểm tra dữ liệu exif của ảnh nữa. Dễ dàng với Glide .

Google đã giới thiệu cho chúng tôi Thư viện trình tải hình ảnh dành cho Android do công ty quảng cáo phát triển có tên Glide là thư viện được Google đề xuất. Nó đã được sử dụng trong nhiều dự án nguồn mở của Google cho đến nay bao gồm cả ứng dụng chính thức của Google I / O 2014.

Ví dụ: Glide.with (context) .load (uri) .into (imageview);

Để biết thêm: 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);
    }

Hy vọng điều này sẽ giúp !! Cảm ơn


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

}

Tôi hy vọng điều này sẽ giúp ích. Cảm ơn!


0

Chỉ gặp vấn đề tương tự ở đây, đoạn mã bên dưới phù hợp với tôi:

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

hy vọng điều này sẽ giúp :)


0

Hãy thử điều này trong lệnh gọi lại 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);

0

// nhấp vào nút

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

            });

// phương thức 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());
        }
    }

// tạo một đường dẫn tệp lớp

lớp công khai 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

Mã này có chức năng cho biến phong cảnh và chân dung @frontCameraID = khiến nó trở thành phương pháp cổ điển cho máy ảnh hiển thị mong muốn

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

Phương pháp lấy hướng y xoay để lưu ảnh và hướng hiển thị @result = hướng trên chế độ xem trước của máy ảnh @rotationPicture = cần xoay để lưu ảnh chính xác

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

Ai đó câu hỏi về mã, xin vui lòng cho tôi biết.


-2

hai giải pháp Một dòng sử dụng Picasso và thư viện lượn

Sau khi dành rất nhiều thời gian với rất nhiều giải pháp cho vấn đề xoay hình ảnh cuối cùng tôi đã tìm ra hai giải pháp đơn giản. Chúng tôi không cần phải làm bất kỳ công việc bổ sung nào. Picasso và Glide là một thư viện rất mạnh mẽ để xử lý hình ảnh trong ứng dụng của bạn. Nó sẽ đọc dữ liệu EXIF ​​hình ảnh và tự động xoay hình ảnh.

Sử dụng thư viện glide https://github.com/bumptech/glide

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

Sử dụng thư viện Picasso https://github.com/square/picasso

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

Chào mừng đến với SO. Hãy tránh hỏi cho upvotes: meta.stackexchange.com/questions/194061/...
Jans
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.