.
├── QrCodeActivity.java
├── camera
│   ├── AutoFocusCallback.java
│   ├── CameraConfigurationManager.java
│   ├── CameraManager.java
│   └── PreviewCallback.java
├── decode
│   ├── CaptureActivityHandler.java
│   ├── DecodeHandler.java
│   ├── DecodeImageCallback.java
 

│   ├── DecodeImageThread.java
│   ├── DecodeManager.java
│   ├── DecodeThread.java
│   ├── FinishListener.java
│   └── InactivityTimer.java
├── utils
│   ├── QrUtils.java
│   └── ScreenUtils.java
└── view
    └── QrCodeFinderView.java

/**
 * Reads, one time, values from the camera that are needed by the app.
 */
void initFromCameraParameters(OpenCamera camera) {
    Camera.Parameters parameters = camera.getCamera().getParameters();
    WindowManager manager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = manager.getDefaultDisplay();

    // 判斷螢幕方向，是否有需要從自然角度旋轉到顯示器角度
    int displayRotation = display.getRotation();
    int cwRotationFromNaturalToDisplay;
    switch (displayRotation) {
        case Surface.ROTATION_0:
            cwRotationFromNaturalToDisplay = 0;
            break;
        case Surface.ROTATION_90:
            cwRotationFromNaturalToDisplay = 90;
            break;
        case Surface.ROTATION_180:
            cwRotationFromNaturalToDisplay = 180;
            break;
        case Surface.ROTATION_270:
            cwRotationFromNaturalToDisplay = 270;
            break;
        default:
            // Have seen this return incorrect values like -90
            if (displayRotation % 90 == 0) {
                cwRotationFromNaturalToDisplay = (360 + displayRotation) % 360;
            } else {
                throw new IllegalArgumentException("Bad rotation: " + displayRotation);
            }
    }
    Log.i(TAG, "Display at: " + cwRotationFromNaturalToDisplay);

    //判斷相機的方向，根據前後攝像機判斷是否有需要旋轉
    int cwRotationFromNaturalToCamera = camera.getOrientation();
    Log.i(TAG, "Camera at: " + cwRotationFromNaturalToCamera);

    // Still not 100% sure about this. But acts like we need to flip this:
    if (camera.getFacing() == CameraFacing.FRONT) {
        cwRotationFromNaturalToCamera = (360 - cwRotationFromNaturalToCamera) % 360;
        Log.i(TAG, "Front camera overriden to: " + cwRotationFromNaturalToCamera);
    }

    //根據螢幕方向和相機方向判斷是否有需要進行旋轉
    cwRotationFromDisplayToCamera = (360 + cwRotationFromNaturalToCamera - cwRotationFromNaturalToDisplay) % 360;
    Log.i(TAG, "Final display orientation: " + cwRotationFromDisplayToCamera);
    if (camera.getFacing() == CameraFacing.FRONT) {
        Log.i(TAG, "Compensating rotation for front camera");
        cwNeededRotation = (360 - cwRotationFromDisplayToCamera) % 360;
    } else {
        cwNeededRotation = cwRotationFromDisplayToCamera;
    }
    Log.i(TAG, "Clockwise rotation from display to camera: " + cwNeededRotation);

    Point theScreenResolution = new Point();
    display.getSize(theScreenResolution);
    screenResolution = theScreenResolution;
    Log.i(TAG, "Screen resolution in current orientation: " + screenResolution);
    // 尋找最佳的預覽寬高值
    cameraResolution = CameraConfigurationUtils.findBestPreviewSizeValue(parameters, screenResolution);
    Log.i(TAG, "Camera resolution: " + cameraResolution);
    bestPreviewSize = CameraConfigurationUtils.findBestPreviewSizeValue(parameters, screenResolution);
    Log.i(TAG, "Best available preview size: " + bestPreviewSize);

    boolean isScreenPortrait = screenResolution.x < screenResolution.y;
    boolean isPreviewSizePortrait = bestPreviewSize.x < bestPreviewSize.y;

    if (isScreenPortrait == isPreviewSizePortrait) {
        previewSizeOnScreen = bestPreviewSize;
    } else {
        previewSizeOnScreen = new Point(bestPreviewSize.y, bestPreviewSize.x);
    }
    Log.i(TAG, "Preview size on screen: " + previewSizeOnScreen);
}

public static Point findBestPreviewSizeValue(Camera.Parameters parameters, Point screenResolution) {

    // 獲取當前手機支援的螢幕預覽尺寸
    List<Camera.Size> rawSupportedSizes = parameters.getSupportedPreviewSizes();
    if (rawSupportedSizes == null) {
        Log.w(TAG, "Device returned no supported preview sizes; using default");
        Camera.Size defaultSize = parameters.getPreviewSize();
        if (defaultSize == null) {
            throw new IllegalStateException("Parameters contained no preview size!");
        }
        return new Point(defaultSize.width, defaultSize.height);
    }

    // 對這些尺寸根據畫素值（即寬乘高的值）進行重小到大排序
    List<Camera.Size> supportedPreviewSizes = new ArrayList<>(rawSupportedSizes);
    Collections.sort(supportedPreviewSizes, new Comparator<Camera.Size>() {
        @Override
        public int compare(Camera.Size a, Camera.Size b) {
            int aPixels = a.height * a.width;
            int bPixels = b.height * b.width;
            if (bPixels < aPixels) {
                return -1;
            }
            if (bPixels > aPixels) {
                return 1;
            }
            return 0;
        }
    });

    double screenAspectRatio = (double) screenResolution.x / (double) screenResolution.y;

    Iterator<Camera.Size> it = supportedPreviewSizes.iterator();
    while (it.hasNext()) {
        Camera.Size supportedPreviewSize = it.next();
        int realWidth = supportedPreviewSize.width;
        int realHeight = supportedPreviewSize.height;
        // 首先把不符合最小預覽畫素值的尺寸排除
        if (realWidth * realHeight < MIN_PREVIEW_PIXELS) {
            it.remove();
            continue;
        }

        boolean isCandidatePortrait = realWidth < realHeight;
        int maybeFlippedWidth = isCandidatePortrait ? realHeight : realWidth;
        int maybeFlippedHeight = isCandidatePortrait ? realWidth : realHeight;
        double aspectRatio = (double) maybeFlippedWidth / (double) maybeFlippedHeight;
        double distortion = Math.abs(aspectRatio - screenAspectRatio);
        // 根據寬高比判斷是否滿足最大誤差要求（預設最大值為0.15，即寬高比預設不能超過給定比例的15%）
        if (distortion > MAX_ASPECT_DISTORTION) {
            it.remove();
            continue;
        }

        if (maybeFlippedWidth == screenResolution.x && maybeFlippedHeight == screenResolution.y) {
            Point exactPoint = new Point(realWidth, realHeight);
            Log.i(TAG, "Found preview size exactly matching screen size: " + exactPoint);
            return exactPoint;
        }
    }

    // 如果沒有精確匹配到合適的尺寸，則使用最大的尺寸，這樣設定便是預覽影象可能產生拉伸的根本原因。
    if (!supportedPreviewSizes.isEmpty()) {
        Camera.Size largestPreview = supportedPreviewSizes.get(0);
        Point largestSize = new Point(largestPreview.width, largestPreview.height);
        Log.i(TAG, "Using largest suitable preview size: " + largestSize);
        return largestSize;
    }

    // 如果沒有找到合適的尺寸，就返回預設設定的尺寸
    Camera.Size defaultPreview = parameters.getPreviewSize();
    if (defaultPreview == null) {
        throw new IllegalStateException("Parameters contained no preview size!");
    }
    Point defaultSize = new Point(defaultPreview.width, defaultPreview.height);
    Log.i(TAG, "No suitable preview sizes, using default: " + defaultSize);
    return defaultSize;
}

/**
 * 預覽尺寸與給定的寬高尺寸比較器。首先比較寬高的比例，在寬高比相同的情況下，根據寬和高的最小差進行比較。
 */
private static class SizeComparator implements Comparator<Camera.Size> {

    private final int width;
    private final int height;
    private final float ratio;

    SizeComparator(int width, int height) {
        if (width < height) {
            this.width = height;
            this.height = width;
        } else {
            this.width = width;
            this.height = height;
        }
        this.ratio = (float) this.height / this.width;
    }

    @Override
    public int compare(Camera.Size size1, Camera.Size size2) {
        int width1 = size1.width;
        int height1 = size1.height;
        int width2 = size2.width;
        int height2 = size2.height;

        float ratio1 = Math.abs((float) height1 / width1 - ratio);
        float ratio2 = Math.abs((float) height2 / width2 - ratio);
        int result = Float.compare(ratio1, ratio2);
        if (result != 0) {
            return result;
        } else {
            int minGap1 = Math.abs(width - width1) + Math.abs(height - height1);
            int minGap2 = Math.abs(width - width2) + Math.abs(height - height2);
            return minGap1 - minGap2;
        }
    }
}

/**
 * 通過對比得到與寬高比最接近的尺寸（如果有相同尺寸，優先選擇）
 *
 * @param surfaceWidth 需要被進行對比的原寬
 * @param surfaceHeight 需要被進行對比的原高
 * @param preSizeList 需要對比的預覽尺寸列表
 * @return 得到與原寬高比例最接近的尺寸
 */
protected Camera.Size findCloselySize(int surfaceWidth, int surfaceHeight, List<Camera.Size> preSizeList) {
    Collections.sort(preSizeList, new SizeComparator(surfaceWidth, surfaceHeight));
    return preSizeList.get(0);
}

void initFromCameraParameters(Camera camera) {
    Camera.Parameters parameters = camera.getParameters();
    mCameraResolution = findCloselySize(ScreenUtils.getScreenWidth(mContext), ScreenUtils.getScreenHeight(mContext),
        parameters.getSupportedPreviewSizes());
    Log.e(TAG, "Setting preview size: " + mCameraResolution.width + "-" + mCameraResolution.height);
    mPictureResolution = findCloselySize(ScreenUtils.getScreenWidth(mContext),
        ScreenUtils.getScreenHeight(mContext), parameters.getSupportedPictureSizes());
    Log.e(TAG, "Setting picture size: " + mPictureResolution.width + "-" + mPictureResolution.height);
}

private void decode(byte[] data, int width, int height) {
    long start = System.currentTimeMillis();
    Result rawResult = null;
    // 構造基於平面的YUV亮度源，即包含二維碼區域的資料來源
    PlanarYUVLuminanceSource source = activity.getCameraManager().buildLuminanceSource(data, width, height);
    if (source != null) {
        // 構造二值影象位元流，使用HybridBinarizer演算法解析資料來源
        BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
        try {
            // 採用MultiFormatReader解析影象，可以解析多種資料格式
            rawResult = multiFormatReader.decodeWithState(bitmap);
        } catch (ReaderException re) {
            // continue
        } finally {
            multiFormatReader.reset();
        }
    }
	···
	// Hanlder處理解析失敗或成功的結果
	···
}

private static final int MIN_FRAME_WIDTH = 240;
private static final int MIN_FRAME_HEIGHT = 240;
private static final int MAX_FRAME_WIDTH = 1200; // = 5/8 * 1920
private static final int MAX_FRAME_HEIGHT = 675; // = 5/8 * 1080

/**
 * A factory method to build the appropriate LuminanceSource object based on the format of the preview buffers, as
 * described by Camera.Parameters.
 *
 * @param data A preview frame.
 * @param width The width of the image.
 * @param height The height of the image.
 * @return A PlanarYUVLuminanceSource instance.
 */
public PlanarYUVLuminanceSource buildLuminanceSource(byte[] data, int width, int height) {
    // 取得預覽框內的矩形
    Rect rect = getFramingRectInPreview();
    if (rect == null) {
        return null;
    }
    // Go ahead and assume it's YUV rather than die.
    return new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top, rect.width(), rect.height(),
        false);
}

/**
 * Like {@link #getFramingRect} but coordinates are in terms of the preview frame, not UI / screen.
 *
 * @return {@link Rect} expressing barcode scan area in terms of the preview size
 */
public synchronized Rect getFramingRectInPreview() {
    if (framingRectInPreview == null) {
        Rect framingRect = getFramingRect();
        if (framingRect == null) {
            return null;
        }
        // 獲取相機解析度和螢幕解析度
        Rect rect = new Rect(framingRect);
        Point cameraResolution = configManager.getCameraResolution();
        Point screenResolution = configManager.getScreenResolution();
        if (cameraResolution == null || screenResolution == null) {
            // Called early, before init even finished
            return null;
        }
        // 根據相機解析度和螢幕解析度的比例對螢幕中央聚焦框進行調整
        rect.left = rect.left * cameraResolution.x / screenResolution.x;
        rect.right = rect.right * cameraResolution.x / screenResolution.x;
        rect.top = rect.top * cameraResolution.y / screenResolution.y;
        rect.bottom = rect.bottom * cameraResolution.y / screenResolution.y;
        framingRectInPreview = rect;
    }
    return framingRectInPreview;
}

/**
 * Calculates the framing rect which the UI should draw to show the user where to place the barcode. This target
 * helps with alignment as well as forces the user to hold the device far enough away to ensure the image will be in
 * focus.
 *
 * @return The rectangle to draw on screen in window coordinates.
 */
public synchronized Rect getFramingRect() {
    if (framingRect == null) {
        if (camera == null) {
            return null;
        }
        // 獲取螢幕的尺寸畫素
        Point screenResolution = configManager.getScreenResolution();
        if (screenResolution == null) {
            // Called early, before init even finished
            return null;
        }
        // 根據螢幕的寬高找到最合適的矩形框寬高值
        int width = findDesiredDimensionInRange(screenResolution.x, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
        int height = findDesiredDimensionInRange(screenResolution.y, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);

        // 取螢幕中間的，寬為width，高為height的矩形框
        int leftOffset = (screenResolution.x - width) / 2;
        int topOffset = (screenResolution.y - height) / 2;
        framingRect = new Rect(leftOffset, topOffset, leftOffset + width, topOffset + height);
        Log.d(TAG, "Calculated framing rect: " + framingRect);
    }
    return framingRect;
}

private static int findDesiredDimensionInRange(int resolution, int hardMin, int hardMax) {
    int dim = 5 * resolution / 8; // Target 5/8 of each dimension
    if (dim < hardMin) {
        return hardMin;
    }
    if (dim > hardMax) {
        return hardMax;
    }
    return dim;
}

public PlanarYUVLuminanceSource buildLuminanceSource(byte[] data, int width, int height) {
    // 直接返回整幅影象的資料，而不計算聚焦框大小。
    return new PlanarYUVLuminanceSource(data, width, height, 0, 0, width, height, false);
}

private final Map<DecodeHintType, Object> mHints;
DecodeHandler(QrCodeActivity activity) {
    this.mActivity = activity;
    mQrCodeReader = new QRCodeReader();
    mHints = new Hashtable<>();
    mHints.put(DecodeHintType.CHARACTER_SET, "utf-8");
    mHints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
    mHints.put(DecodeHintType.POSSIBLE_FORMATS, BarcodeFormat.QR_CODE);
}

private String cameraFormatForPixelFormat(int pixel_format) {
    switch(pixel_format) {
    case ImageFormat.NV16:      return PIXEL_FORMAT_YUV422SP;
    case ImageFormat.NV21:      return PIXEL_FORMAT_YUV420SP;
    case ImageFormat.YUY2:      return PIXEL_FORMAT_YUV422I;
    case ImageFormat.YV12:      return PIXEL_FORMAT_YUV420P;
    case ImageFormat.RGB_565:   return PIXEL_FORMAT_RGB565;
    case ImageFormat.JPEG:      return PIXEL_FORMAT_JPEG;
    default:                    return null;
    }
}