CameraConfigurationManager.java 源代码

package cn.bingoogolapple.qrcode.core;

import android.content.Context;
import android.graphics.Point;
import android.hardware.Camera;
import android.view.WindowManager;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

final class CameraConfigurationManager {
    private Point mCameraResolution;
    private final Context mContext;
    private Point mPreviewResolution;

    public CameraConfigurationManager(Context context) {
        this.mContext = context;
    }

    public void initFromCameraParameters(Camera camera) {
        Point screenResolution = BGAQRCodeUtil.getScreenResolution(this.mContext);
        Point point = new Point();
        point.x = screenResolution.x;
        point.y = screenResolution.y;
        if (BGAQRCodeUtil.isPortrait(this.mContext)) {
            point.x = screenResolution.y;
            point.y = screenResolution.x;
        }
        this.mPreviewResolution = getPreviewResolution(camera.getParameters(), point);
        if (BGAQRCodeUtil.isPortrait(this.mContext)) {
            this.mCameraResolution = new Point(this.mPreviewResolution.y, this.mPreviewResolution.x);
        } else {
            this.mCameraResolution = this.mPreviewResolution;
        }
    }

    private static boolean autoFocusAble(Camera camera) {
        return findSettableValue(camera.getParameters().getSupportedFocusModes(), "auto") != null;
    }

    public Point getCameraResolution() {
        return this.mCameraResolution;
    }

    public void setDesiredCameraParameters(Camera camera) {
        Camera.Parameters parameters = camera.getParameters();
        parameters.setPreviewSize(this.mPreviewResolution.x, this.mPreviewResolution.y);
        int[] selectPreviewFpsRange = selectPreviewFpsRange(camera, 60.0f);
        if (selectPreviewFpsRange != null) {
            parameters.setPreviewFpsRange(selectPreviewFpsRange[0], selectPreviewFpsRange[1]);
        }
        camera.setDisplayOrientation(getDisplayOrientation());
        camera.setParameters(parameters);
    }

    private int[] selectPreviewFpsRange(Camera camera, float f) {
        int i = (int) (f * 1000.0f);
        int[] iArr = null;
        int i2 = Integer.MAX_VALUE;
        for (int[] iArr2 : camera.getParameters().getSupportedPreviewFpsRange()) {
            int abs = Math.abs(i - iArr2[0]) + Math.abs(i - iArr2[1]);
            if (abs < i2) {
                iArr = iArr2;
                i2 = abs;
            }
        }
        return iArr;
    }

    public void openFlashlight(Camera camera) {
        doSetTorch(camera, true);
    }

    public void closeFlashlight(Camera camera) {
        doSetTorch(camera, false);
    }

    private void doSetTorch(Camera camera, boolean z) {
        String findSettableValue;
        Camera.Parameters parameters = camera.getParameters();
        if (z) {
            findSettableValue = findSettableValue(parameters.getSupportedFlashModes(), "torch", "on");
        } else {
            findSettableValue = findSettableValue(parameters.getSupportedFlashModes(), "off");
        }
        if (findSettableValue != null) {
            parameters.setFlashMode(findSettableValue);
        }
        camera.setParameters(parameters);
    }

    private static String findSettableValue(Collection<String> collection, String... strArr) {
        if (collection != null) {
            for (String str : strArr) {
                if (collection.contains(str)) {
                    return str;
                }
            }
        }
        return null;
    }

    private int getDisplayOrientation() {
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        int i = 0;
        Camera.getCameraInfo(0, cameraInfo);
        WindowManager windowManager = (WindowManager) this.mContext.getSystemService("window");
        if (windowManager == null) {
            return 0;
        }
        int rotation = windowManager.getDefaultDisplay().getRotation();
        if (rotation != 0) {
            if (rotation == 1) {
                i = 90;
            } else if (rotation == 2) {
                i = 180;
            } else if (rotation == 3) {
                i = 270;
            }
        }
        if (cameraInfo.facing == 1) {
            return (360 - ((cameraInfo.orientation + i) % 360)) % 360;
        }
        return ((cameraInfo.orientation - i) + 360) % 360;
    }

    private static Point getPreviewResolution(Camera.Parameters parameters, Point point) {
        Point findBestPreviewSizeValue = findBestPreviewSizeValue(parameters.getSupportedPreviewSizes(), point);
        return findBestPreviewSizeValue == null ? new Point((point.x >> 3) << 3, (point.y >> 3) << 3) : findBestPreviewSizeValue;
    }

    private static Point findBestPreviewSizeValue(List<Camera.Size> list, Point point) {
        Iterator<Camera.Size> it = list.iterator();
        int i = 0;
        int i2 = Integer.MAX_VALUE;
        int i3 = 0;
        while (true) {
            if (!it.hasNext()) {
                break;
            }
            Camera.Size next = it.next();
            int i4 = next.width;
            int i5 = next.height;
            int abs = Math.abs(i4 - point.x) + Math.abs(i5 - point.y);
            if (abs == 0) {
                i3 = i5;
                i = i4;
                break;
            }
            if (abs < i2) {
                i3 = i5;
                i = i4;
                i2 = abs;
            }
        }
        if (i <= 0 || i3 <= 0) {
            return null;
        }
        return new Point(i, i3);
    }
}