身份证采集页面UI开发

hhh
1 parent 88aea392
Showing 67 changed files with 4750 additions and 26 deletions
.idea/misc.xml
app/strike/build.gradle
app/strike/src/main/AndroidManifest.xml
app/strike/src/main/java/com/cnlive/strike/MainActivity.java
app/strike/src/main/java/com/cnlive/strike/imgutil/UgcActivity.java
app/strike/src/main/res/layout/activity_main.xml
app/strike/src/main/res/layout/activity_ugc.xml
core/base/src/main/res/drawable-hdpi/top_back_black.webp
core/base/src/main/res/drawable-xhdpi/top_back_black.webp
core/base/src/main/res/drawable-xxhdpi/top_back_black.webp
core/base/src/main/res/values/ids.xml
core/dentity_verfication/build.gradle
core/dentity_verfication/libs/license.jar
core/dentity_verfication/libs/ocr-sdk.jar
core/dentity_verfication/src/main/AndroidManifest.xml
core/dentity_verfication/src/main/assets/models/integrity_model_secret.bin
core/dentity_verfication/src/main/assets/models/quality_model_secret.bin
core/dentity_verfication/src/main/java/com/cnlive/core/ocr/RecognizeService.java
core/dentity_verfication/src/main/java/com/cnlive/core/ocr/idcardquality/IDcardQualityProcess.java
core/dentity_verfication/src/main/java/com/cnlive/core/ocr/ui/camera/Camera1Control.java
@@ -39,7 +39,7 @@
       </value>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="JDK" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">
@@ -187,5 +187,6 @@ dependencies {
 //    implementation project(path: ':core:encipher')
 //    implementation project(path: ':cloud:user')
     implementation project(path: ':cloud:wjj_lib')
+    implementation project(path: ':core:dentity_verfication')
  
 }
@@ -17,7 +17,8 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
-        <activity android:name="com.cnlive.strike.imgutil.SimplePrevActivity"></activity>
+        <activity android:name="com.cnlive.strike.imgutil.UgcActivity"></activity>
+        <activity android:name="com.cnlive.strike.imgutil.SimplePrevActivity" />
         <activity android:name="com.cnlive.strike.demo.activity.HappyChinaActivity" />
  
         <provider
@@ -54,7 +55,6 @@
             </intent-filter>
         </activity>
         <activity android:name="com.cnlive.strike.demo.activity.DemoMvpActivity" />
-
         <activity android:name="com.cnlive.strike.demo.activity.DemoBottomSheetActivity" />
  
         <meta-data
@@ -10,6 +10,7 @@ import android.view.View;
 import com.cnlive.cloud.R;
 import com.cnlive.strike.demo.activity.DemoMvpActivity;
 import com.cnlive.strike.imgutil.ImgActivity;
+import com.cnlive.strike.imgutil.UgcActivity;
  
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -30,6 +31,7 @@ public class MainActivity extends AppCompatActivity {
             }
         });
         findViewById(R.id.to_img).setOnClickListener(view -> startActivity(new Intent(this, ImgActivity.class)));
+        findViewById(R.id.ugc_btn).setOnClickListener(view -> startActivity(new Intent(this, UgcActivity.class)));
     }
  
     @Nullable
+package com.cnlive.strike.imgutil;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.cnlive.cloud.R;
+import com.cnlive.core.people_verfication.activity.TakeIdentityPictureActivity;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+public class UgcActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_ugc);
+        findViewById(R.id.people_denty).setOnClickListener(view -> startActivity(new Intent(this, TakeIdentityPictureActivity.class)));
+    }
+}
@@ -20,5 +20,12 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="图片加载测试"/>
+
+        <Button
+            android:id="@+id/ugc_btn"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="ugc直播认证"
+            />
     </LinearLayout>
 </layout>
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.cnlive.strike.imgutil.UgcActivity">
+
+    <Button
+        android:id="@+id/people_denty"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="个人认证"
+        />
+</LinearLayout>
@@ -7,4 +7,5 @@
     <item name="isexpand" type="id"></item>
     <!--    -->
     <item name="rightBtn" type="id" />
+    <item name="fragment_back" type="id" />
 </resources>
 \ No newline at end of file
@@ -5,11 +5,12 @@ android {
 }
  
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
-
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
     implementation 'androidx.appcompat:appcompat:1.0.2'
     implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+    implementation "com.cnlive.libs:mediapicker:$rootProject.libMediaPicker"
+    implementation files('libs/license.jar')
 }
@@ -2,8 +2,23 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.cnlive.core.people_verfication">
  
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <uses-feature android:name="android.hardware.camera2.full" />
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
     <application>
-        <activity android:name=".TakePictureActivity"></activity>
+        <activity android:name=".activity.TakeIdentityPictureActivity"></activity>
+        <activity
+            android:name="com.cnlive.core.ocr.ui.camera.CameraActivity"
+            android:configChanges="screenSize|orientation"
+            android:theme="@android:style/Theme.Holo.NoActionBar.Fullscreen"
+            android:launchMode="singleTop"
+            android:screenOrientation="portrait"/>
     </application>
  
 </manifest>
 \ No newline at end of file
+package com.cnlive.core.ocr;
+
+import android.content.Context;
+import android.util.Log;
+
+import com.baidu.ocr.sdk.OCR;
+import com.baidu.ocr.sdk.OnResultListener;
+import com.baidu.ocr.sdk.exception.OCRError;
+import com.baidu.ocr.sdk.model.AccessToken;
+import com.baidu.ocr.sdk.model.BankCardParams;
+import com.baidu.ocr.sdk.model.BankCardResult;
+import com.baidu.ocr.sdk.model.IDCardParams;
+import com.baidu.ocr.sdk.model.IDCardResult;
+
+import java.io.File;
+
+/**
+ * @author Lynn
+ * @date 2018/1/4
+ */
+
+public class RecognizeService {
+
+    /**
+     * 识别银行卡
+     *
+     * @param filePath 文件路径
+     * @param listener 回调
+     */
+    public static void recBankCard(String filePath, OnResultListener<BankCardResult> listener) {
+        BankCardParams params = new BankCardParams();
+        params.setImageFile(new File(filePath));
+        OCR.getInstance().recognizeBankCard(params, listener);
+    }
+
+    /**
+     * 识别身份证
+     *
+     * @param idCardSide 身份证正反面
+     * @param filePath   文件路径
+     * @param listener   回调
+     */
+    public static void recIDCard(String idCardSide, String filePath, OnResultListener<IDCardResult> listener) {
+        IDCardParams param = new IDCardParams();
+        param.setImageFile(new File(filePath));
+        // 设置身份证正反面
+        param.setIdCardSide(idCardSide);
+        // 设置方向检测
+        param.setDetectDirection(true);
+        // 设置图像参数压缩质量0-100, 越大图像质量越好但是请求时间越长。 不设置则默认值为20
+        param.setImageQuality(20);
+        OCR.getInstance().recognizeIDCard(param, listener);
+    }
+
+    /**
+     * 初始化 with AK & SK
+     *
+     * @param context context
+     */
+    public static void initAccessTokenWithAkSk(final Context context) {
+        OCR.getInstance().initAccessTokenWithAkSk(new OnResultListener<AccessToken>() {
+            @Override
+            public void onResult(AccessToken result) {
+                String token = result.getAccessToken();
+                Log.e("LynnTest", result.toString());
+            }
+
+            @Override
+            public void onError(OCRError error) {
+                error.printStackTrace();
+                Log.e("LynnTest", error.getMessage());
+            }
+        }, context, "YIGsVzdh35y3GCaNUDsxM3cC", "neAe1orXgeTaiHkAbygrgCevKe1fPrG1");
+    }
+
+    /**
+     * 初始化 授权文件（安全模式）
+     *
+     * @param context
+     */
+    public static void initAccessToken(Context context) {
+        OCR.getInstance().initAccessToken(new OnResultListener<AccessToken>() {
+            @Override
+            public void onResult(AccessToken accessToken) {
+                String token = accessToken.getAccessToken();
+            }
+
+            @Override
+            public void onError(OCRError ocrError) {
+
+            }
+        }, context);
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.idcardquality;
+
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+
+import com.baidu.idl.authority.AlgorithmOnMainThreadException;
+import com.baidu.idl.authority.IDLAuthorityException;
+import com.baidu.idl.license.License;
+import com.baidu.idl.util.UIThread;
+
+
+public class IDcardQualityProcess {
+
+    private static IDcardQualityProcess mInstance;
+    private static String tokenString;
+    private static int mAuthorityStatus;
+    private static Throwable loadNativeException = null;
+    private static volatile boolean hasReleased;
+
+    public IDcardQualityProcess() {
+    }
+
+    public static synchronized IDcardQualityProcess getInstance() {
+        if (null == mInstance) {
+            mInstance = new IDcardQualityProcess();
+        }
+
+        return mInstance;
+    }
+
+    public native byte[] convertRGBImage(int[] colors, int width, int height);
+
+    public native int idcardQualityModelInit(AssetManager var1, String var2);
+
+    public native int idcardQualityCaptchaRelease();
+
+    public native int idcardQualityProcess(byte[] var1, int var2, int var3, boolean var4, int var5);
+
+    public static synchronized int init(String token) throws AlgorithmOnMainThreadException, IDLAuthorityException {
+        if (UIThread.isUITread()) {
+            throw new AlgorithmOnMainThreadException();
+        } else {
+            tokenString = token;
+
+            try {
+                mAuthorityStatus = License.getInstance().init(tokenString);
+            } catch (Exception var2) {
+                if (var2!=null)
+                var2.printStackTrace();
+            }
+
+            return mAuthorityStatus;
+        }
+    }
+
+    public int idcardQualityInit(AssetManager assetManager, String modelPath) {
+        if (mAuthorityStatus == 0) {
+            hasReleased = false;
+            return this.idcardQualityModelInit(assetManager, modelPath);
+        } else {
+            return mAuthorityStatus;
+        }
+    }
+
+    public int idcardQualityRelease() {
+        if (mAuthorityStatus == 0) {
+            hasReleased = true;
+            this.idcardQualityCaptchaRelease();
+            return 0;
+        } else {
+            return mAuthorityStatus;
+        }
+    }
+
+    public int idcardQualityDetectionImg(Bitmap img, boolean isfont) {
+        if (mAuthorityStatus == 0) {
+            if (hasReleased) {
+                return -1;
+            }
+            int imgHeight = img.getHeight();
+            int imgWidth = img.getWidth();
+            byte[] imageData = this.getRGBImageData(img);
+            return this.idcardQualityProcess(imageData, imgHeight, imgWidth, isfont, 3);
+        } else {
+            return mAuthorityStatus;
+        }
+    }
+
+    public static Throwable getLoadSoException() {
+        return loadNativeException;
+    }
+
+    public byte[] getRGBImageData(Bitmap img) {
+        int imgWidth = img.getWidth();
+        int imgHeight = img.getHeight();
+        int[] pixels = new int[imgWidth * imgHeight];
+        img.getPixels(pixels, 0, imgWidth, 0, 0, imgWidth, imgHeight);
+        byte[] imageData = convertRGBImage(pixels, imgWidth, imgHeight);
+        return imageData;
+    }
+
+    public void releaseModel() {
+        this.idcardQualityRelease();
+    }
+
+    static {
+        try {
+            System.loadLibrary("idl_license");
+            System.loadLibrary("idcard_quality.1.1.1");
+        } catch (Throwable e) {
+            loadNativeException = e;
+        }
+        mInstance = null;
+        mAuthorityStatus = 256;
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.FeatureInfo;
+import android.content.pm.PackageManager;
+import android.graphics.ImageFormat;
+import android.graphics.Rect;
+import android.graphics.SurfaceTexture;
+import android.graphics.YuvImage;
+import android.hardware.Camera;
+import android.os.Build;
+import android.util.Log;
+import android.view.TextureView;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import com.cnlive.core.libs.base.util.AlertUtil;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import androidx.core.app.ActivityCompat;
+
+/**
+ * 5.0以下相机API的封装。
+ */
+@SuppressWarnings("deprecation")
+public class Camera1Control implements ICameraControl {
+
+    private int displayOrientation = 0;
+    private int cameraId = 0;
+    private int flashMode;
+    private AtomicBoolean takingPicture = new AtomicBoolean(false);
+    private AtomicBoolean abortingScan = new AtomicBoolean(false);
+    private Context context;
+    private Camera camera;
+
+    private Camera.Parameters parameters;
+    private PermissionCallback permissionCallback;
+    private Rect previewFrame = new Rect();
+
+    private PreviewView previewView;
+    private View displayView;
+    private int rotation = 0;
+    private OnDetectPictureCallback detectCallback;
+    private int previewFrameCount = 0;
+    private Camera.Size optSize;
+
+    /*
+     * 非扫描模式
+     */
+    private final int MODEL_NOSCAN = 0;
+
+    /*
+     * 本地质量控制扫描模式
+     */
+    private final int MODEL_SCAN = 1;
+
+    private int detectType = MODEL_NOSCAN;
+
+    public int getCameraRotation() {
+        return rotation;
+    }
+
+    public AtomicBoolean getAbortingScan() {
+        return abortingScan;
+    }
+
+    @Override
+    public void setDetectCallback(OnDetectPictureCallback callback) {
+        detectType = MODEL_SCAN;
+        detectCallback = callback;
+    }
+
+    private void onRequestDetect(byte[] data) {
+        // 相机已经关闭
+        if (camera == null || data == null) {
+            return;
+        }
+
+        YuvImage img = new YuvImage(data, ImageFormat.NV21, optSize.width, optSize.height, null);
+        ByteArrayOutputStream os = null;
+        try {
+            os = new ByteArrayOutputStream(data.length);
+            img.compressToJpeg(new Rect(0, 0, optSize.width, optSize.height), 80, os);
+            byte[] jpeg = os.toByteArray();
+            int status = detectCallback.onDetect(jpeg, getCameraRotation());
+
+            if (status == 0) {
+                clearPreviewCallback();
+            }
+        } catch (OutOfMemoryError e) {
+            // 内存溢出则取消当次操作
+        } finally {
+            try {
+                os.close();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    @Override
+    public void setDisplayOrientation(@CameraView.Orientation int displayOrientation) {
+        this.displayOrientation = displayOrientation;
+        switch (displayOrientation) {
+            case CameraView.ORIENTATION_PORTRAIT:
+                rotation = 90;
+                break;
+            case CameraView.ORIENTATION_HORIZONTAL:
+                rotation = 0;
+                break;
+            case CameraView.ORIENTATION_INVERT:
+                rotation = 180;
+                break;
+            default:
+                rotation = 0;
+        }
+        previewView.requestLayout();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void refreshPermission() {
+        startPreview(true);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void setFlashMode(@FlashMode int flashMode) {
+        if (this.flashMode == flashMode) {
+            return;
+        }
+        this.flashMode = flashMode;
+        updateFlashMode(flashMode);
+    }
+
+    @Override
+    public int getFlashMode() {
+        return flashMode;
+    }
+
+    @Override
+    public void start() {
+
+    }
+
+    @Override
+    public void stop() {
+        if (camera != null) {
+            camera.setPreviewCallback(null);
+            stopPreview();
+            // 避免同步代码，为了先设置null后release
+            Camera tempC = camera;
+            camera = null;
+            tempC.release();
+            camera = null;
+            buffer = null;
+        }
+    }
+
+    private void stopPreview() {
+        if (camera != null) {
+            camera.stopPreview();
+        }
+    }
+
+    @Override
+    public void pause() {
+        if (camera != null) {
+            stopPreview();
+        }
+        setFlashMode(FLASH_MODE_OFF);
+    }
+
+    @Override
+    public void resume() {
+        takingPicture.set(false);
+        if (camera == null) {
+            openCamera();
+        } else {
+            previewView.textureView.setSurfaceTextureListener(surfaceTextureListener);
+            if (previewView.textureView.isAvailable()) {
+                startPreview(false);
+            }
+        }
+    }
+
+    @Override
+    public View getDisplayView() {
+        return displayView;
+    }
+
+    @Override
+    public void takePicture(final OnTakePictureCallback onTakePictureCallback) {
+        if (takingPicture.get()) {
+            return;
+        }
+        try {
+            switch (displayOrientation) {
+                case CameraView.ORIENTATION_PORTRAIT:
+                    parameters.setRotation(90);
+                    break;
+                case CameraView.ORIENTATION_HORIZONTAL:
+                    parameters.setRotation(0);
+                    break;
+                case CameraView.ORIENTATION_INVERT:
+                    parameters.setRotation(180);
+                    break;
+            }
+            Camera.Size picSize = getOptimalSize(camera.getParameters().getSupportedPictureSizes());
+            parameters.setPictureSize(picSize.width, picSize.height);
+            camera.setParameters(parameters);
+            takingPicture.set(true);
+
+            camera.takePicture(null, null, new Camera.PictureCallback() {
+                @Override
+                public void onPictureTaken(byte[] data, Camera camera) {
+                    startPreview(false);
+                    takingPicture.set(false);
+                    if (onTakePictureCallback != null) {
+                        onTakePictureCallback.onPictureTaken(data);
+                    }
+                }
+            });
+        } catch (RuntimeException e) {
+            e.printStackTrace();
+            startPreview(false);
+            ;
+            takingPicture.set(false);
+        }
+    }
+
+    @Override
+    public void setPermissionCallback(PermissionCallback callback) {
+        this.permissionCallback = callback;
+    }
+
+    public Camera1Control(Context context) {
+        this.context = context;
+        previewView = new PreviewView(context);
+        openCamera();
+    }
+
+    private void openCamera() {
+        setupDisplayView();
+    }
+
+    private void setupDisplayView() {
+        final TextureView textureView = new TextureView(context);
+        previewView.textureView = textureView;
+        previewView.setTextureView(textureView);
+        displayView = previewView;
+        textureView.setSurfaceTextureListener(surfaceTextureListener);
+    }
+
+    private SurfaceTexture surfaceCache;
+
+    private byte[] buffer = null;
+
+    private void setPreviewCallbackImpl() {
+        if (buffer == null) {
+            buffer = new byte[displayView.getWidth()
+                    * displayView.getHeight() * ImageFormat.getBitsPerPixel(ImageFormat.NV21) / 8];
+        }
+        if (camera != null && detectType == MODEL_SCAN) {
+            camera.addCallbackBuffer(buffer);
+            camera.setPreviewCallback(previewCallback);
+        }
+    }
+
+    private void clearPreviewCallback() {
+        if (camera != null && detectType == MODEL_SCAN) {
+            camera.setPreviewCallback(null);
+            stopPreview();
+        }
+    }
+
+    Camera.PreviewCallback previewCallback = new Camera.PreviewCallback() {
+        @Override
+        public void onPreviewFrame(final byte[] data, Camera camera) {
+            // 扫描成功阻止打开新线程处理
+            if (abortingScan.get()) {
+                return;
+            }
+            // 节流
+            if (previewFrameCount++ % 5 != 0) {
+                return;
+            }
+
+            // 在某些机型和某项项目中，某些帧的data的数据不符合nv21的格式，需要过滤，否则后续处理会导致crash
+            if (data.length != parameters.getPreviewSize().width * parameters.getPreviewSize().height * 1.5) {
+                return;
+            }
+
+            camera.addCallbackBuffer(buffer);
+
+            CameraThreadPool.execute(new Runnable() {
+                @Override
+                public void run() {
+                    Camera1Control.this.onRequestDetect(data);
+                }
+            });
+        }
+    };
+
+
+    private void initCamera() {
+        try {
+            if (camera == null) {
+                Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
+                for (int i = 0; i < Camera.getNumberOfCameras(); i++) {
+                    Camera.getCameraInfo(i, cameraInfo);
+                    if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
+                        cameraId = i;
+                    }
+                }
+                try {
+                    camera = Camera.open(cameraId);
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    startPreview(true);
+                    return;
+                }
+
+            }
+            if (parameters == null) {
+                parameters = camera.getParameters();
+                parameters.setPreviewFormat(ImageFormat.NV21);
+            }
+            opPreviewSize(previewView.getWidth(), previewView.getHeight());
+            camera.setPreviewTexture(surfaceCache);
+            setPreviewCallbackImpl();
+            startPreview(false);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private TextureView.SurfaceTextureListener surfaceTextureListener = new TextureView.SurfaceTextureListener() {
+        @Override
+        public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+            surfaceCache = surface;
+            initCamera();
+        }
+
+        @Override
+        public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+            opPreviewSize(previewView.getWidth(), previewView.getHeight());
+            setPreviewCallbackImpl();
+        }
+
+        @Override
+        public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+            return false;
+        }
+
+        @Override
+        public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+            setPreviewCallbackImpl();
+        }
+    };
+
+    // 开启预览
+    private void startPreview(boolean checkPermission) {
+        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
+                != PackageManager.PERMISSION_GRANTED) {
+            if (checkPermission && permissionCallback != null) {
+                permissionCallback.onRequestPermission();
+            }
+            return;
+        }
+        if (camera == null) {
+            initCamera();
+        } else {
+            try {
+                camera.startPreview();
+                CameraThreadPool.createAutoFocusTimerTask(new Runnable() {
+                    @Override
+                    public void run() {
+                        synchronized (Camera1Control.this) {
+                            if (camera != null && !takingPicture.get()) {
+                                try {
+                                    camera.autoFocus(new Camera.AutoFocusCallback() {
+                                        @Override
+                                        public void onAutoFocus(boolean success, Camera camera) {
+                                        }
+                                    });
+                                } catch (Throwable e) {
+                                    // startPreview是异步实现，可能在某些机器上前几次调用会autofocus failß
+                                }
+                            }
+                        }
+                    }
+                });
+            } catch (Exception e) {
+                Log.e("ocr_ui startPreview", "startPreview: " + (e == null ? "" : e.getMessage()));
+            }
+        }
+    }
+
+    private void opPreviewSize(int width, @SuppressWarnings("unused") int height) {
+
+        if (parameters != null && camera != null && width > 0) {
+            try {
+                optSize = getOptimalSize(camera.getParameters().getSupportedPreviewSizes());
+            }catch (Exception e){
+                e.printStackTrace();
+            }
+            optSize = getOptimalSize(camera.getParameters().getSupportedPreviewSizes());
+            parameters.setPreviewSize(optSize.width, optSize.height);
+            previewView.setRatio(1.0f * optSize.width / optSize.height);
+
+            camera.setDisplayOrientation(getSurfaceOrientation());
+            stopPreview();
+            try {
+                camera.setParameters(parameters);
+            } catch (RuntimeException e) {
+                e.printStackTrace();
+
+            }
+            startPreview(false);
+        }
+    }
+
+    private Camera.Size getOptimalSize(List<Camera.Size> sizes) {
+        int width = previewView.textureView.getWidth();
+        int height = previewView.textureView.getHeight();
+        Camera.Size pictureSize = sizes.get(0);
+
+        List<Camera.Size> candidates = new ArrayList<>();
+
+        for (Camera.Size size : sizes) {
+            if (size.width >= width && size.height >= height && size.width * height == size.height * width) {
+                // 比例相同
+                candidates.add(size);
+            } else if (size.height >= width && size.width >= height && size.width * width == size.height * height) {
+                // 反比例
+                candidates.add(size);
+            }
+        }
+        if (!candidates.isEmpty()) {
+            return Collections.min(candidates, sizeComparator);
+        }
+
+        for (Camera.Size size : sizes) {
+            if (size.width > width && size.height > height) {
+                return size;
+            }
+        }
+
+        return pictureSize;
+    }
+
+    private Comparator<Camera.Size> sizeComparator = new Comparator<Camera.Size>() {
+        @Override
+        public int compare(Camera.Size lhs, Camera.Size rhs) {
+            return Long.signum((long) lhs.width * lhs.height - (long) rhs.width * rhs.height);
+        }
+    };
+
+    private void updateFlashMode(int flashMode) {
+        switch (flashMode) {
+            case FLASH_MODE_TORCH:
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                    try {
+                        parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }else {
+                    boolean isUse = false;
+                    PackageManager packageManager = context.getPackageManager();
+                    FeatureInfo[] features = packageManager.getSystemAvailableFeatures();
+                    for (FeatureInfo featureInfo : features) {
+                        if (PackageManager.FEATURE_CAMERA_FLASH.equals(featureInfo.name)) { // 断设备是否支持闪光灯
+                            try {
+                                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
+                                isUse = true;
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+                    if(!isUse) AlertUtil.showDeftToast(context,"该设备不支持闪光灯");
+                }
+                break;
+            case FLASH_MODE_OFF:
+                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
+                break;
+            case ICameraControl.FLASH_MODE_AUTO:
+                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
+                break;
+            default:
+                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
+                break;
+        }
+        if (parameters == null || camera == null)
+            return;
+        camera.setParameters(parameters);
+    }
+
+    private int getSurfaceOrientation() {
+        @CameraView.Orientation
+        int orientation = displayOrientation;
+        switch (orientation) {
+            case CameraView.ORIENTATION_PORTRAIT:
+                return 90;
+            case CameraView.ORIENTATION_HORIZONTAL:
+                return 0;
+            case CameraView.ORIENTATION_INVERT:
+                return 180;
+            default:
+                return 90;
+        }
+    }
+
+    /**
+     * 有些相机匹配不到完美的比例。比如。我们的layout是4:3的。预览只有16:9
+     * 的，如果直接显示图片会拉伸，变形。缩放的话，又有黑边。所以我们采取的策略
+     * 是，等比例放大。这样预览的有一部分会超出屏幕。拍照后再进行裁剪处理。
+     */
+    private class PreviewView extends FrameLayout {
+
+        private TextureView textureView;
+
+        private float ratio = 0.75f;
+
+        void setTextureView(TextureView textureView) {
+            this.textureView = textureView;
+            removeAllViews();
+            addView(textureView);
+        }
+
+        void setRatio(float ratio) {
+            this.ratio = ratio;
+            requestLayout();
+            relayout(getWidth(), getHeight());
+        }
+
+        public PreviewView(Context context) {
+            super(context);
+        }
+
+        @Override
+        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+            super.onSizeChanged(w, h, oldw, oldh);
+            relayout(w, h);
+        }
+
+        private void relayout(int w, int h) {
+            int width = w;
+            int height = h;
+            if (w < h) {
+                // 垂直模式，高度固定。
+                height = (int) (width * ratio);
+            } else {
+                // 水平模式，宽度固定。
+                width = (int) (height * ratio);
+            }
+
+            int l = (getWidth() - width) / 2;
+            int t = (getHeight() - height) / 2;
+
+            previewFrame.left = l;
+            previewFrame.top = t;
+            previewFrame.right = l + width;
+            previewFrame.bottom = t + height;
+        }
+
+        @Override
+        protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+            super.onLayout(changed, left, top, right, bottom);
+            textureView.layout(previewFrame.left, previewFrame.top, previewFrame.right, previewFrame.bottom);
+        }
+    }
+
+    @Override
+    public Rect getPreviewFrame() {
+        return previewFrame;
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+
+package com.cnlive.core.ocr.ui.camera;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.ImageFormat;
+import android.graphics.Matrix;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.SurfaceTexture;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.camera2.TotalCaptureResult;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.media.Image;
+import android.media.ImageReader;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Size;
+import android.util.SparseIntArray;
+import android.view.Surface;
+import android.view.TextureView;
+import android.view.View;
+import android.view.WindowManager;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+
+@TargetApi(Build.VERSION_CODES.LOLLIPOP)
+public class Camera2Control implements ICameraControl {
+    @Override
+    public void setDetectCallback(OnDetectPictureCallback callback) {
+        // TODO 暂时只用camera
+    }
+
+    @Override
+    public AtomicBoolean getAbortingScan() {
+        // TODO 暂时只用camera
+        return null;
+    }
+
+    /**
+     * Conversion from screen rotation to JPEG orientation.
+     */
+    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
+    private static final int MAX_PREVIEW_SIZE = 2048;
+
+    static {
+        ORIENTATIONS.append(Surface.ROTATION_0, 90);
+        ORIENTATIONS.append(Surface.ROTATION_90, 0);
+        ORIENTATIONS.append(Surface.ROTATION_180, 270);
+        ORIENTATIONS.append(Surface.ROTATION_270, 180);
+    }
+
+    private static final int STATE_PREVIEW = 0;
+    private static final int STATE_WAITING_FOR_LOCK = 1;
+    private static final int STATE_WAITING_FOR_CAPTURE = 2;
+    private static final int STATE_CAPTURING = 3;
+    private static final int STATE_PICTURE_TAKEN = 4;
+
+    private static final int MAX_PREVIEW_WIDTH = 1920;
+    private static final int MAX_PREVIEW_HEIGHT = 1080;
+
+    private int flashMode;
+    private int orientation = 0;
+    private int state = STATE_PREVIEW;
+
+    private Context context;
+    private OnTakePictureCallback onTakePictureCallback;
+    private PermissionCallback permissionCallback;
+
+    private String cameraId;
+    private TextureView textureView;
+    private Size previewSize;
+    private Rect previewFrame = new Rect();
+
+    private HandlerThread backgroundThread;
+    private Handler backgroundHandler;
+    private ImageReader imageReader;
+    private CameraCaptureSession captureSession;
+    private CameraDevice cameraDevice;
+
+    private CaptureRequest.Builder previewRequestBuilder;
+    private CaptureRequest previewRequest;
+
+    private Semaphore cameraLock = new Semaphore(1);
+    private int sensorOrientation;
+
+    @Override
+    public void start() {
+        startBackgroundThread();
+        if (textureView.isAvailable()) {
+            openCamera(textureView.getWidth(), textureView.getHeight());
+            textureView.setSurfaceTextureListener(surfaceTextureListener);
+        } else {
+            textureView.setSurfaceTextureListener(surfaceTextureListener);
+        }
+    }
+
+    @Override
+    public void stop() {
+        textureView.setSurfaceTextureListener(null);
+        closeCamera();
+        stopBackgroundThread();
+    }
+
+    @Override
+    public void pause() {
+        setFlashMode(FLASH_MODE_OFF);
+    }
+
+    @Override
+    public void resume() {
+        state = STATE_PREVIEW;
+    }
+
+    @Override
+    public View getDisplayView() {
+        return textureView;
+    }
+
+    @Override
+    public Rect getPreviewFrame() {
+        return previewFrame;
+    }
+
+    @Override
+    public void takePicture(OnTakePictureCallback callback) {
+        this.onTakePictureCallback = callback;
+        // 拍照第一步，对焦
+        lockFocus();
+    }
+
+    @Override
+    public void setPermissionCallback(PermissionCallback callback) {
+        this.permissionCallback = callback;
+    }
+
+    @Override
+    public void setDisplayOrientation(@CameraView.Orientation int displayOrientation) {
+        this.orientation = displayOrientation / 90;
+    }
+
+    @Override
+    public void refreshPermission() {
+        openCamera(textureView.getWidth(), textureView.getHeight());
+    }
+
+    @Override
+    public void setFlashMode(@FlashMode int flashMode) {
+        if (this.flashMode == flashMode) {
+            return;
+        }
+        this.flashMode = flashMode;
+        try {
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
+                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+            updateFlashMode(flashMode, previewRequestBuilder);
+            previewRequest = previewRequestBuilder.build();
+            captureSession.setRepeatingRequest(previewRequest, captureCallback, backgroundHandler);
+        } catch (Exception e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public int getFlashMode() {
+        return flashMode;
+    }
+
+    public Camera2Control(Context activity) {
+        this.context = activity;
+        textureView = new TextureView(activity);
+    }
+
+    private final TextureView.SurfaceTextureListener surfaceTextureListener =
+            new TextureView.SurfaceTextureListener() {
+                @Override
+                public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) {
+                    openCamera(width, height);
+                }
+
+                @Override
+                public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) {
+                    configureTransform(width, height);
+                    previewFrame.left = 0;
+                    previewFrame.top = 0;
+                    previewFrame.right = width;
+                    previewFrame.bottom = height;
+                }
+
+                @Override
+                public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
+                    stop();
+                    return true;
+                }
+
+                @Override
+                public void onSurfaceTextureUpdated(SurfaceTexture texture) {
+                }
+            };
+
+    @SuppressLint("MissingPermission")
+    private void openCamera(int width, int height) {
+        // 6.0+的系统需要检查系统权限 。
+        if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
+                != PackageManager.PERMISSION_GRANTED) {
+            requestCameraPermission();
+            return;
+        }
+        setUpCameraOutputs(width, height);
+        configureTransform(width, height);
+        CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+        try {
+            if (!cameraLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
+                throw new RuntimeException("Time out waiting to lock camera opening.");
+            }
+            manager.openCamera(cameraId, deviceStateCallback, backgroundHandler);
+        } catch (CameraAccessException e) {
+            if (e!=null)
+            e.printStackTrace();
+        } catch (InterruptedException e) {
+            if (e!=null)
+            throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
+        }
+    }
+
+    private final CameraDevice.StateCallback deviceStateCallback = new CameraDevice.StateCallback() {
+        @Override
+        public void onOpened(@NonNull CameraDevice cameraDevice) {
+            cameraLock.release();
+            Camera2Control.this.cameraDevice = cameraDevice;
+            createCameraPreviewSession();
+        }
+
+        @Override
+        public void onDisconnected(@NonNull CameraDevice cameraDevice) {
+            cameraLock.release();
+            cameraDevice.close();
+            Camera2Control.this.cameraDevice = null;
+        }
+
+        @Override
+        public void onError(@NonNull CameraDevice cameraDevice, int error) {
+            cameraLock.release();
+            cameraDevice.close();
+            Camera2Control.this.cameraDevice = null;
+        }
+    };
+
+    private void createCameraPreviewSession() {
+        try {
+            SurfaceTexture texture = textureView.getSurfaceTexture();
+            assert texture != null;
+            texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
+            Surface surface = new Surface(texture);
+            previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+            previewRequestBuilder.addTarget(surface);
+            updateFlashMode(this.flashMode, previewRequestBuilder);
+            cameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()),
+                    new CameraCaptureSession.StateCallback() {
+
+                        @Override
+                        public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
+                            // The camera is already closed
+                            if (null == cameraDevice) {
+                                return;
+                            }
+                            captureSession = cameraCaptureSession;
+                            try {
+                                previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
+                                        CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+                                previewRequest = previewRequestBuilder.build();
+                                captureSession.setRepeatingRequest(previewRequest,
+                                        captureCallback, backgroundHandler);
+                            } catch (CameraAccessException e) {
+                                if (e!=null)
+                                e.printStackTrace();
+                            }
+                        }
+
+                        @Override
+                        public void onConfigureFailed(
+                                @NonNull CameraCaptureSession cameraCaptureSession) {
+                            // TODO
+                        }
+                    }, null
+            );
+        } catch (CameraAccessException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+    }
+
+    private final ImageReader.OnImageAvailableListener onImageAvailableListener =
+            new ImageReader.OnImageAvailableListener() {
+                @Override
+                public void onImageAvailable(ImageReader reader) {
+                    if (onTakePictureCallback != null) {
+                        Image image = reader.acquireNextImage();
+                        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
+                        byte[] bytes = new byte[buffer.remaining()];
+                        buffer.get(bytes);
+
+                        image.close();
+                        onTakePictureCallback.onPictureTaken(bytes);
+                    }
+                }
+            };
+
+    private CameraCaptureSession.CaptureCallback captureCallback =
+            new CameraCaptureSession.CaptureCallback() {
+                private void process(CaptureResult result) {
+                    switch (state) {
+                        case STATE_PREVIEW: {
+                            break;
+                        }
+                        case STATE_WAITING_FOR_LOCK: {
+                            Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
+                            if (afState == null) {
+                                captureStillPicture();
+                                return;
+                            }
+                            switch (afState) {
+                                case CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED:
+                                case CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
+                                case CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED: {
+                                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
+                                    if (aeState == null
+                                            || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
+                                        captureStillPicture();
+                                    } else {
+                                        runPreCaptureSequence();
+                                    }
+                                    break;
+                                }
+                                default:
+                                    captureStillPicture();
+                            }
+                            break;
+                        }
+                        case STATE_WAITING_FOR_CAPTURE: {
+                            Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
+                            if (aeState == null
+                                    || aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE
+                                    || aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
+                                state = STATE_CAPTURING;
+                            } else {
+                                if (aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
+                                    captureStillPicture();
+                                }
+                            }
+                            break;
+                        }
+                        case STATE_CAPTURING: {
+                            Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
+                            if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
+                                captureStillPicture();
+                            }
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+                }
+
+                @Override
+                public void onCaptureProgressed(@NonNull CameraCaptureSession session,
+                                                @NonNull CaptureRequest request,
+                                                @NonNull CaptureResult partialResult) {
+                    process(partialResult);
+                }
+
+                @Override
+                public void onCaptureCompleted(@NonNull CameraCaptureSession session,
+                                               @NonNull CaptureRequest request,
+                                               @NonNull TotalCaptureResult result) {
+                    process(result);
+                }
+
+            };
+
+    private Size getOptimalSize(Size[] choices, int textureViewWidth,
+                                int textureViewHeight, int maxWidth, int maxHeight, Size aspectRatio) {
+        List<Size> bigEnough = new ArrayList<>();
+        List<Size> notBigEnough = new ArrayList<>();
+        int w = aspectRatio.getWidth();
+        int h = aspectRatio.getHeight();
+        for (Size option : choices) {
+            if (option.getWidth() <= maxWidth && option.getHeight() <= maxHeight
+                    && option.getHeight() == option.getWidth() * h / w) {
+                if (option.getWidth() >= textureViewWidth
+                        && option.getHeight() >= textureViewHeight) {
+                    bigEnough.add(option);
+                } else {
+                    notBigEnough.add(option);
+                }
+            }
+        }
+
+        // Pick the smallest of those big enough. If there is no one big enough, pick the
+        // largest of those not big enough.
+        if (bigEnough.size() > 0) {
+            return Collections.min(bigEnough, sizeComparator);
+        }
+
+        for (Size option : choices) {
+            if (option.getWidth() >= maxWidth && option.getHeight() >= maxHeight) {
+                return option;
+            }
+        }
+
+        if (notBigEnough.size() > 0) {
+            return Collections.max(notBigEnough, sizeComparator);
+        }
+
+        return choices[0];
+    }
+
+    private Comparator<Size> sizeComparator = new Comparator<Size>() {
+        @Override
+        public int compare(Size lhs, Size rhs) {
+            return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
+        }
+    };
+
+    private void requestCameraPermission() {
+        if (permissionCallback != null) {
+            permissionCallback.onRequestPermission();
+        }
+    }
+
+    @SuppressWarnings("SuspiciousNameCombination")
+    private void setUpCameraOutputs(int width, int height) {
+        CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+        try {
+            for (String cameraId : manager.getCameraIdList()) {
+                CameraCharacteristics characteristics =
+                        manager.getCameraCharacteristics(cameraId);
+
+                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
+                if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
+                    continue;
+                }
+
+                StreamConfigurationMap map = characteristics.get(
+                        CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+                if (map == null) {
+                    continue;
+                }
+
+                //                int preferredPictureSize = (int) (Math.max(textureView.getWidth(), textureView
+                // .getHeight()) * 1.5);
+                //                preferredPictureSize = Math.min(preferredPictureSize, 2560);
+
+                WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+                Point screenSize = new Point();
+                windowManager.getDefaultDisplay().getSize(screenSize);
+                int maxImageSize = Math.max(MAX_PREVIEW_SIZE, screenSize.y * 3 / 2);
+
+                Size size = getOptimalSize(map.getOutputSizes(ImageFormat.JPEG), textureView.getWidth(),
+                        textureView.getHeight(), maxImageSize, maxImageSize, new Size(4, 3));
+
+                imageReader = ImageReader.newInstance(size.getWidth(), size.getHeight(),
+                        ImageFormat.JPEG, 1);
+                imageReader.setOnImageAvailableListener(
+                        onImageAvailableListener, backgroundHandler);
+
+                int displayRotation = orientation;
+                // noinspection ConstantConditions
+                sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+                boolean swappedDimensions = false;
+                switch (displayRotation) {
+                    case Surface.ROTATION_0:
+                    case Surface.ROTATION_180:
+                        if (sensorOrientation == 90 || sensorOrientation == 270) {
+                            swappedDimensions = true;
+                        }
+                        break;
+                    case Surface.ROTATION_90:
+                    case Surface.ROTATION_270:
+                        if (sensorOrientation == 0 || sensorOrientation == 180) {
+                            swappedDimensions = true;
+                        }
+                        break;
+                    default:
+                }
+
+                int rotatedPreviewWidth = width;
+                int rotatedPreviewHeight = height;
+                int maxPreviewWidth = screenSize.x;
+                int maxPreviewHeight = screenSize.y;
+
+                if (swappedDimensions) {
+                    rotatedPreviewWidth = height;
+                    rotatedPreviewHeight = width;
+                    maxPreviewWidth = screenSize.y;
+                    maxPreviewHeight = screenSize.x;
+                }
+
+                maxPreviewWidth = Math.min(maxPreviewWidth, MAX_PREVIEW_WIDTH);
+                maxPreviewHeight = Math.min(maxPreviewHeight, MAX_PREVIEW_HEIGHT);
+
+                previewSize = getOptimalSize(map.getOutputSizes(SurfaceTexture.class),
+                        rotatedPreviewWidth, rotatedPreviewHeight, maxPreviewWidth,
+                        maxPreviewHeight, size);
+                this.cameraId = cameraId;
+                return;
+            }
+        } catch (CameraAccessException | NullPointerException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+    }
+
+    private void closeCamera() {
+        try {
+            cameraLock.acquire();
+            if (null != captureSession) {
+                captureSession.close();
+                captureSession = null;
+            }
+            if (null != cameraDevice) {
+                cameraDevice.close();
+                cameraDevice = null;
+            }
+            if (null != imageReader) {
+                imageReader.close();
+                imageReader = null;
+            }
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
+        } finally {
+            cameraLock.release();
+        }
+    }
+
+    private void startBackgroundThread() {
+        backgroundThread = new HandlerThread("ocr_camera");
+        backgroundThread.start();
+        backgroundHandler = new Handler(backgroundThread.getLooper());
+    }
+
+    private void stopBackgroundThread() {
+        if (backgroundThread != null) {
+            backgroundThread.quitSafely();
+            backgroundThread = null;
+            backgroundHandler = null;
+        }
+    }
+
+    private void configureTransform(int viewWidth, int viewHeight) {
+        if (null == textureView || null == previewSize || null == context) {
+            return;
+        }
+        int rotation = orientation;
+        Matrix matrix = new Matrix();
+        RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
+        RectF bufferRect = new RectF(0, 0, previewSize.getHeight(), previewSize.getWidth());
+        float centerX = viewRect.centerX();
+        float centerY = viewRect.centerY();
+        if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
+            bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
+            matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
+            float scale = Math.max(
+                    (float) viewHeight / previewSize.getHeight(),
+                    (float) viewWidth / previewSize.getWidth());
+            matrix.postScale(scale, scale, centerX, centerY);
+            matrix.postRotate(90 * (rotation - 2), centerX, centerY);
+        } else if (Surface.ROTATION_180 == rotation) {
+            matrix.postRotate(180, centerX, centerY);
+        }
+        textureView.setTransform(matrix);
+    }
+
+    // 拍照前，先对焦
+    private void lockFocus() {
+        if (captureSession != null && state == STATE_PREVIEW) {
+            try {
+                previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
+                        CameraMetadata.CONTROL_AF_TRIGGER_START);
+                state = STATE_WAITING_FOR_LOCK;
+                captureSession.capture(previewRequestBuilder.build(), captureCallback,
+                        backgroundHandler);
+            } catch (CameraAccessException e) {
+                if (e!=null)
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void runPreCaptureSequence() {
+        try {
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
+                    CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
+            state = STATE_WAITING_FOR_CAPTURE;
+            captureSession.capture(previewRequestBuilder.build(), captureCallback,
+                    backgroundHandler);
+        } catch (CameraAccessException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+    }
+
+    // 拍照session
+    private void captureStillPicture() {
+        try {
+            if (null == context || null == cameraDevice) {
+                return;
+            }
+            final CaptureRequest.Builder captureBuilder =
+                    cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
+            captureBuilder.addTarget(imageReader.getSurface());
+            captureBuilder.set(CaptureRequest.CONTROL_AF_MODE,
+                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+
+            captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(orientation));
+            updateFlashMode(this.flashMode, captureBuilder);
+            CameraCaptureSession.CaptureCallback captureCallback =
+                    new CameraCaptureSession.CaptureCallback() {
+                        @Override
+                        public void onCaptureCompleted(@NonNull CameraCaptureSession session,
+                                                       @NonNull CaptureRequest request,
+                                                       @NonNull TotalCaptureResult result) {
+                            unlockFocus();
+                        }
+
+                        @Override
+                        public void onCaptureFailed(@NonNull CameraCaptureSession session,
+                                                    @NonNull CaptureRequest request,
+                                                    @NonNull CaptureFailure failure) {
+                            super.onCaptureFailed(session, request, failure);
+                        }
+                    };
+
+            // 停止预览
+            captureSession.stopRepeating();
+            captureSession.capture(captureBuilder.build(), captureCallback, backgroundHandler);
+            state = STATE_PICTURE_TAKEN;
+            //            unlockFocus();
+        } catch (CameraAccessException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+    }
+
+    private int getOrientation(int rotation) {
+        return (ORIENTATIONS.get(rotation) + sensorOrientation + 270) % 360;
+    }
+
+    // 停止对焦
+    private void unlockFocus() {
+        try {
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
+                    CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
+            captureSession.capture(previewRequestBuilder.build(), captureCallback,
+                    backgroundHandler);
+            state = STATE_PREVIEW;
+            // 预览
+            captureSession.setRepeatingRequest(previewRequest, captureCallback,
+                    backgroundHandler);
+            textureView.setSurfaceTextureListener(surfaceTextureListener);
+        } catch (CameraAccessException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+    }
+
+    private void updateFlashMode(@FlashMode int flashMode, CaptureRequest.Builder builder) {
+        switch (flashMode) {
+            case FLASH_MODE_TORCH:
+                builder.set(CaptureRequest.FLASH_MODE, CameraMetadata.FLASH_MODE_TORCH);
+                break;
+            case FLASH_MODE_OFF:
+                builder.set(CaptureRequest.FLASH_MODE, CameraMetadata.FLASH_MODE_OFF);
+                break;
+            case ICameraControl.FLASH_MODE_AUTO:
+            default:
+                builder.set(CaptureRequest.FLASH_MODE, CameraMetadata.FLASH_MODE_SINGLE);
+                break;
+        }
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.graphics.drawable.BitmapDrawable;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.Handler;
+import android.view.Surface;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.Toast;
+
+import com.cnlive.core.libs.base.util.AlertUtil;
+import com.cnlive.core.ocr.idcardquality.IDcardQualityProcess;
+import com.cnlive.core.ocr.ui.crop.CropView;
+import com.cnlive.core.ocr.ui.crop.FrameOverlayView;
+import com.cnlive.core.people_verfication.R;
+import com.cnlive.media.picker.ImagePicker;
+import com.cnlive.media.picker.PickerConfig;
+import com.cnlive.media.picker.entity.Media;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+
+public class CameraActivity extends Activity {
+
+    public static final String KEY_OUTPUT_FILE_PATH = "outputFilePath";
+    public static final String KEY_CONTENT_TYPE = "contentType";
+    public static final String KEY_NATIVE_TOKEN = "nativeToken";
+    public static final String KEY_NATIVE_ENABLE = "nativeEnable";
+
+    public static final String CONTENT_TYPE_GENERAL = "general";
+    public static final String CONTENT_TYPE_ID_CARD_FRONT = "IDCardFront";
+    public static final String CONTENT_TYPE_ID_CARD_BACK = "IDCardBack";
+    public static final String CONTENT_TYPE_BANK_CARD = "bankCard";
+
+    private static final int REQUEST_CODE_PICK_IMAGE = 100;
+    private static final int PERMISSIONS_REQUEST_CAMERA = 800;
+    private static final int PERMISSIONS_EXTERNAL_STORAGE = 801;
+
+    private File outputFile;
+    private String contentType;
+    private Handler handler = new Handler();
+
+    private OCRCameraLayout takePictureContainer;
+    private OCRCameraLayout cropContainer;
+    private OCRCameraLayout confirmResultContainer;
+    private ImageView lightButton;
+    private CameraView cameraView;
+    private ImageView displayImageView;
+    private CropView cropView;
+    private FrameOverlayView overlayView;
+    private MaskView cropMaskView;
+    private ImageView takePhotoBtn;
+    private ImageView back;
+    //上一个被点击过的btn的点击时间
+    private long preViewClickTime = 0;
+    private PermissionCallback permissionCallback = new PermissionCallback() {
+        @Override
+        public boolean onRequestPermission() {
+            ActivityCompat.requestPermissions(CameraActivity.this,
+                    new String[]{Manifest.permission.CAMERA,
+                            Manifest.permission.WRITE_EXTERNAL_STORAGE,
+                            Manifest.permission.READ_EXTERNAL_STORAGE},
+                    PERMISSIONS_REQUEST_CAMERA);
+            return false;
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.bd_ocr_activity_camera);
+
+        takePictureContainer = (OCRCameraLayout) findViewById(R.id.take_picture_container);
+        confirmResultContainer = (OCRCameraLayout) findViewById(R.id.confirm_result_container);
+
+        cameraView = (CameraView) findViewById(R.id.camera_view);
+        cameraView.getCameraControl().setPermissionCallback(permissionCallback);
+        lightButton = (ImageView) findViewById(R.id.light_button);
+        lightButton.setOnClickListener(lightButtonOnClickListener);
+        takePhotoBtn = (ImageView) findViewById(R.id.take_photo_button);
+        findViewById(R.id.album_button).setOnClickListener(albumButtonOnClickListener);
+        takePhotoBtn.setOnClickListener(takeButtonOnClickListener);
+
+        // confirm result;
+        displayImageView = (ImageView) findViewById(R.id.display_image_view);
+        confirmResultContainer.findViewById(R.id.confirm_button).setOnClickListener(confirmButtonOnClickListener);
+        confirmResultContainer.findViewById(R.id.cancel_button).setOnClickListener(confirmCancelButtonOnClickListener);
+        findViewById(R.id.rotate_button).setOnClickListener(rotateButtonOnClickListener);
+
+        cropView = (CropView) findViewById(R.id.crop_view);
+        cropContainer = (OCRCameraLayout) findViewById(R.id.crop_container);
+        overlayView = (FrameOverlayView) findViewById(R.id.overlay_view);
+        cropContainer.findViewById(R.id.confirm_button).setOnClickListener(cropConfirmButtonListener);
+        cropMaskView = (MaskView) cropContainer.findViewById(R.id.crop_mask_view);
+        cropContainer.findViewById(R.id.cancel_button).setOnClickListener(cropCancelButtonListener);
+        back = findViewById(R.id.back);
+        back.setOnClickListener(finishListener);
+        setOrientation(getResources().getConfiguration());
+        initParams();
+
+        cameraView.setAutoPictureCallback(autoTakePictureCallback);
+    }
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+        cameraView.start();
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        cameraView.stop();
+    }
+
+    private void initParams() {
+        String outputPath = getIntent().getStringExtra(KEY_OUTPUT_FILE_PATH);
+        final String token = getIntent().getStringExtra(KEY_NATIVE_TOKEN);
+        boolean isNativeEnable = getIntent().getBooleanExtra(KEY_NATIVE_ENABLE, true);
+        if (token == null) {
+            isNativeEnable = false;
+        }
+
+        if (outputPath != null) {
+            outputFile = new File(outputPath);
+        }
+
+        contentType = getIntent().getStringExtra(KEY_CONTENT_TYPE);
+        if (contentType == null) {
+            contentType = CONTENT_TYPE_GENERAL;
+        }
+        int maskType;
+        switch (contentType) {
+            case CONTENT_TYPE_ID_CARD_FRONT:
+                maskType = MaskView.MASK_TYPE_ID_CARD_FRONT;
+                overlayView.setVisibility(View.INVISIBLE);
+                if (isNativeEnable) {
+                    takePhotoBtn.setVisibility(View.INVISIBLE);
+                }
+                break;
+            case CONTENT_TYPE_ID_CARD_BACK:
+                maskType = MaskView.MASK_TYPE_ID_CARD_BACK;
+                overlayView.setVisibility(View.INVISIBLE);
+                if (isNativeEnable) {
+                    takePhotoBtn.setVisibility(View.INVISIBLE);
+                }
+                break;
+            case CONTENT_TYPE_BANK_CARD:
+                maskType = MaskView.MASK_TYPE_BANK_CARD;
+                overlayView.setVisibility(View.INVISIBLE);
+                break;
+            case CONTENT_TYPE_GENERAL:
+            default:
+                maskType = MaskView.MASK_TYPE_NONE;
+                cropMaskView.setVisibility(View.INVISIBLE);
+                break;
+        }
+
+        // 身份证本地能力初始化
+        if (maskType == MaskView.MASK_TYPE_ID_CARD_FRONT || maskType == MaskView.MASK_TYPE_ID_CARD_BACK) {
+            if (isNativeEnable) {
+                initNative(token);
+            }
+        }
+        cameraView.setEnableScan(isNativeEnable);
+        cameraView.setMaskType(maskType, this);
+        cropMaskView.setMaskType(maskType);
+    }
+
+    private void initNative(final String token) {
+        CameraThreadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                // 加载本地so失败, 异常返回getloadSoException
+                if (IDcardQualityProcess.getLoadSoException() != null) {
+                    cameraView.setInitNativeStatus(CameraView.NATIVE_SOLOAD_FAIL);
+                    return;
+                }
+                // 授权状态
+                int authStatus = IDcardQualityProcess.init(token);
+                // 加载模型状态
+                int initModelStatus = IDcardQualityProcess.getInstance()
+                        .idcardQualityInit(CameraActivity.this.getAssets(),
+                                "models");
+                if (authStatus != 0) {
+                    cameraView.setInitNativeStatus(CameraView.NATIVE_AUTH_FAIL);
+                    return;
+                }
+                if (initModelStatus != 0) {
+                    cameraView.setInitNativeStatus(CameraView.NATIVE_INIT_FAIL);
+                    return;
+                }
+            }
+        });
+    }
+
+    private void showTakePicture() {
+        cameraView.getCameraControl().resume();
+        updateFlashMode();
+        takePictureContainer.setVisibility(View.VISIBLE);
+        back.setVisibility(View.VISIBLE);
+        confirmResultContainer.setVisibility(View.INVISIBLE);
+        cropContainer.setVisibility(View.INVISIBLE);
+    }
+
+    private void showCrop() {
+        cameraView.getCameraControl().pause();
+        updateFlashMode();
+        takePictureContainer.setVisibility(View.INVISIBLE);
+        back.setVisibility(View.INVISIBLE);
+        confirmResultContainer.setVisibility(View.INVISIBLE);
+        cropContainer.setVisibility(View.VISIBLE);
+    }
+
+    private void showResultConfirm() {
+        cameraView.getCameraControl().pause();
+        updateFlashMode();
+        takePictureContainer.setVisibility(View.INVISIBLE);
+        back.setVisibility(View.INVISIBLE);
+        confirmResultContainer.setVisibility(View.VISIBLE);
+        cropContainer.setVisibility(View.INVISIBLE);
+    }
+
+    // take photo;
+    private void updateFlashMode() {
+        int flashMode = cameraView.getCameraControl().getFlashMode();
+        if (flashMode == ICameraControl.FLASH_MODE_TORCH) {
+            lightButton.setImageResource(R.drawable.bd_ocr_light_on);
+        } else {
+            lightButton.setImageResource(R.drawable.bd_ocr_light_off);
+        }
+    }
+
+    private View.OnClickListener albumButtonOnClickListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            long curClickTime = System.currentTimeMillis();
+            if (preViewClickTime > 0 && curClickTime - preViewClickTime <= 2000 ) {
+                return;
+            }
+            preViewClickTime = curClickTime;
+            if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.READ_EXTERNAL_STORAGE)
+                    != PackageManager.PERMISSION_GRANTED) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+                    ActivityCompat.requestPermissions(CameraActivity.this,
+                            new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
+                            PERMISSIONS_EXTERNAL_STORAGE);
+                    return;
+                }
+            }
+            new ImagePicker
+                    .Builder()
+                    .setSelectGif(false)
+                    .maxImageSize(20 * 1024 * 1024)
+                    //最大选择图片数目，默认40张
+                    .maxNum(1)
+                    //选择模式（默认PICKER_IMAGE_VIDEO）     PICKER_IMAGE-->图片 PICKER_VIDEO-->视频  PICKER_IMAGE_VIDEO-->图片&视频
+                    .selectMode(PickerConfig.PICKER_IMAGE)
+                    //拍照或录像存储位置 默认Environment.getExternalStorageDirectory().getPath() + File.separator + "JCamera"
+                    .cachePath(Environment.getExternalStorageDirectory() + "/strike/file/")
+                    //是否为发朋友圈模式（默认false）  true-->图片与视频不能同时选择
+                    .isFriendCircle(true)
+                    //裁剪 只有在单选模式下才可以使用
+//                    .doCrop(1, 1, 300, 300)
+                    //是否开启单选模式（默认false）
+                    .isSinglePick(true)
+                    .builder()
+                    .start(CameraActivity.this, PickerConfig.PICKER_IMAGE, REQUEST_CODE_PICK_IMAGE);
+        }
+    };
+
+    private View.OnClickListener lightButtonOnClickListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            if (cameraView.getCameraControl().getFlashMode() == ICameraControl.FLASH_MODE_OFF) {
+                cameraView.getCameraControl().setFlashMode(ICameraControl.FLASH_MODE_TORCH);
+            } else {
+                cameraView.getCameraControl().setFlashMode(ICameraControl.FLASH_MODE_OFF);
+            }
+            updateFlashMode();
+        }
+    };
+
+    private View.OnClickListener takeButtonOnClickListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            if (ActivityCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA)
+                    != PackageManager.PERMISSION_GRANTED) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+                    ActivityCompat.requestPermissions(CameraActivity.this,
+                            new String[]{Manifest.permission.CAMERA,
+                                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
+                                    Manifest.permission.READ_EXTERNAL_STORAGE},
+                            PERMISSIONS_REQUEST_CAMERA);
+                    return;
+                }
+            }
+            cameraView.takePicture(outputFile, takePictureCallback);
+        }
+    };
+
+    private CameraView.OnTakePictureCallback autoTakePictureCallback = new CameraView.OnTakePictureCallback() {
+        @Override
+        public void onPictureTaken(final Bitmap bitmap) {
+            CameraThreadPool.execute(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
+                        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
+                        bitmap.recycle();
+                        fileOutputStream.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                    Intent intent = new Intent();
+                    intent.putExtra(CameraActivity.KEY_CONTENT_TYPE, contentType);
+                    setResult(Activity.RESULT_OK, intent);
+                    finish();
+                }
+            });
+        }
+    };
+
+    private CameraView.OnTakePictureCallback takePictureCallback = new CameraView.OnTakePictureCallback() {
+        @Override
+        public void onPictureTaken(final Bitmap bitmap) {
+            handler.post(new Runnable() {
+                @Override
+                public void run() {
+                    takePictureContainer.setVisibility(View.INVISIBLE);
+                    back.setVisibility(View.INVISIBLE);
+                    if (cropMaskView.getMaskType() == MaskView.MASK_TYPE_NONE) {
+                        cropView.setFilePath(outputFile.getAbsolutePath());
+                        showCrop();
+                    } else if (cropMaskView.getMaskType() == MaskView.MASK_TYPE_BANK_CARD) {
+                        cropView.setFilePath(outputFile.getAbsolutePath());
+                        cropMaskView.setVisibility(View.INVISIBLE);
+                        overlayView.setVisibility(View.VISIBLE);
+                        overlayView.setTypeWide();
+                        showCrop();
+                    } else {
+                        displayImageView.setImageBitmap(bitmap);
+                        showResultConfirm();
+                    }
+                }
+            });
+        }
+    };
+
+    private View.OnClickListener cropCancelButtonListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            // 释放 cropView中的bitmap;
+            cropView.setFilePath(null);
+            showTakePicture();
+        }
+    };
+
+
+    private View.OnClickListener finishListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            finish();
+        }
+    };
+
+    private View.OnClickListener cropConfirmButtonListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            int maskType = cropMaskView.getMaskType();
+            Rect rect;
+            switch (maskType) {
+                case MaskView.MASK_TYPE_BANK_CARD:
+                case MaskView.MASK_TYPE_ID_CARD_BACK:
+                case MaskView.MASK_TYPE_ID_CARD_FRONT:
+                    rect = cropMaskView.getFrameRect();
+                    break;
+                case MaskView.MASK_TYPE_NONE:
+                default:
+                    rect = overlayView.getFrameRect();
+                    break;
+            }
+            Bitmap cropped = cropView.crop(rect);
+            if(cropped == null){
+                return;
+            }
+            displayImageView.setImageBitmap(cropped);
+            cropAndConfirm();
+        }
+    };
+
+    private void cropAndConfirm() {
+        cameraView.getCameraControl().pause();
+        updateFlashMode();
+        doConfirmResult();
+    }
+
+    private void doConfirmResult() {
+        CameraThreadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
+                    Bitmap bitmap = ((BitmapDrawable) displayImageView.getDrawable()).getBitmap();
+                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
+                    fileOutputStream.close();
+                } catch (IOException e) {
+                    if (e!=null)
+                    e.printStackTrace();
+                }
+                Intent intent = new Intent();
+                intent.putExtra(CameraActivity.KEY_CONTENT_TYPE, contentType);
+                setResult(Activity.RESULT_OK, intent);
+                finish();
+            }
+        });
+    }
+
+    private View.OnClickListener confirmButtonOnClickListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            doConfirmResult();
+        }
+    };
+
+    private View.OnClickListener confirmCancelButtonOnClickListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            displayImageView.setImageBitmap(null);
+            showTakePicture();
+        }
+    };
+
+    private View.OnClickListener rotateButtonOnClickListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            cropView.rotate(90);
+        }
+    };
+
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+        setOrientation(newConfig);
+    }
+
+    private void setOrientation(Configuration newConfig) {
+        int rotation = getWindowManager().getDefaultDisplay().getRotation();
+        int orientation;
+        int cameraViewOrientation = CameraView.ORIENTATION_PORTRAIT;
+        switch (newConfig.orientation) {
+            case Configuration.ORIENTATION_PORTRAIT:
+                cameraViewOrientation = CameraView.ORIENTATION_PORTRAIT;
+                orientation = OCRCameraLayout.ORIENTATION_PORTRAIT;
+                break;
+            case Configuration.ORIENTATION_LANDSCAPE:
+                orientation = OCRCameraLayout.ORIENTATION_HORIZONTAL;
+                if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_90) {
+                    cameraViewOrientation = CameraView.ORIENTATION_HORIZONTAL;
+                } else {
+                    cameraViewOrientation = CameraView.ORIENTATION_INVERT;
+                }
+                break;
+            default:
+                orientation = OCRCameraLayout.ORIENTATION_PORTRAIT;
+                cameraView.setOrientation(CameraView.ORIENTATION_PORTRAIT);
+                break;
+        }
+        takePictureContainer.setOrientation(orientation);
+        cameraView.setOrientation(cameraViewOrientation);
+        cropContainer.setOrientation(orientation);
+        confirmResultContainer.setOrientation(orientation);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (requestCode == REQUEST_CODE_PICK_IMAGE && data != null) {
+            ArrayList<Media> select = data.getParcelableArrayListExtra(PickerConfig.EXTRA_RESULT);
+            String path = select.get(0).path;
+            cropView.setFilePath(path);
+            showCrop();
+        }else {
+            cameraView.getCameraControl().resume();
+        }
+    }
+
+
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
+                                           @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        switch (requestCode) {
+            case PERMISSIONS_REQUEST_CAMERA: {
+                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+                    cameraView.getCameraControl().refreshPermission();
+                } else {
+                    AlertUtil.showLongToast(getApplicationContext(), getString(R.string.camera_permission_required), Toast.LENGTH_LONG);
+                }
+                break;
+            }
+            case PERMISSIONS_EXTERNAL_STORAGE:
+                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+
+                } else {
+                    AlertUtil.showLongToast(getApplicationContext(), getString(R.string.permission_required), Toast.LENGTH_LONG);
+                }
+            default:
+                break;
+        }
+    }
+
+    /**
+     * 做一些收尾工作，把这些工作从onDestory中移到正确的位置
+     * 可以以防止新的activity启动后被调用
+     */
+    private void doClear() {
+        CameraThreadPool.cancelAutoFocusTimer();
+        IDcardQualityProcess.getInstance().releaseModel();
+    }
+
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        this.doClear();
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class CameraThreadPool {
+
+    static Timer timerFocus = null;
+
+    /*
+     * 对焦频率
+     */
+    static final long cameraScanInterval = 2000;
+
+    /*
+     * 线程池大小
+     */
+    private static int poolCount = Runtime.getRuntime().availableProcessors();
+
+    private static ExecutorService fixedThreadPool = Executors.newFixedThreadPool(poolCount);
+
+    /**
+     * 给线程池添加任务
+     *
+     * @param runnable 任务
+     */
+    public static void execute(Runnable runnable) {
+        fixedThreadPool.execute(runnable);
+    }
+
+    /**
+     * 创建一个定时对焦的timer任务
+     *
+     * @param runnable 对焦代码
+     * @return Timer Timer对象，用来终止自动对焦
+     */
+    public static Timer createAutoFocusTimerTask(final Runnable runnable) {
+        if (timerFocus != null) {
+            return timerFocus;
+        }
+        timerFocus = new Timer();
+        TimerTask task = new TimerTask() {
+            @Override
+            public void run() {
+                runnable.run();
+            }
+        };
+        timerFocus.scheduleAtFixedRate(task, 0, cameraScanInterval);
+        return timerFocus;
+    }
+
+    /**
+     * 终止自动对焦任务，实际调用了cancel方法并且清空对象
+     * 但是无法终止执行中的任务，需额外处理
+     */
+    public static void cancelAutoFocusTimer() {
+        if (timerFocus != null) {
+            timerFocus.cancel();
+            timerFocus = null;
+        }
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.BitmapRegionDecoder;
+import android.graphics.Color;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.cnlive.core.ocr.idcardquality.IDcardQualityProcess;
+import com.cnlive.core.ocr.ui.util.ImageUtil;
+import com.cnlive.core.ocr.ui.util.PxUtil;
+import com.cnlive.core.people_verfication.R;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import androidx.annotation.IntDef;
+
+/**
+ * 负责，相机的管理。同时提供，裁剪遮罩功能。
+ */
+public class CameraView extends FrameLayout {
+
+    private int maskType;
+
+    /**
+     * 照相回调
+     */
+    interface OnTakePictureCallback {
+        void onPictureTaken(Bitmap bitmap);
+    }
+
+    /**
+     * 垂直方向 {@link #setOrientation(int)}
+     */
+    public static final int ORIENTATION_PORTRAIT = 0;
+    /**
+     * 水平方向 {@link #setOrientation(int)}
+     */
+    public static final int ORIENTATION_HORIZONTAL = 90;
+    /**
+     * 水平翻转方向 {@link #setOrientation(int)}
+     */
+    public static final int ORIENTATION_INVERT = 270;
+
+    /**
+     * 本地模型授权，加载成功
+     */
+    public static final int NATIVE_AUTH_INIT_SUCCESS = 0;
+
+    /**
+     * 本地模型授权，加载成功
+     */
+    public static final int NATIVE_SOLOAD_FAIL = 10;
+
+    /**
+     * 本地模型授权，加载成功
+     */
+    public static final int NATIVE_AUTH_FAIL = 11;
+
+    /**
+     * 本地模型授权，加载成功
+     */
+    public static final int NATIVE_INIT_FAIL = 12;
+
+
+    /**
+     * 是否已经通过本地质量控制扫描
+     */
+    private final int SCAN_SUCCESS = 0;
+
+    public void setInitNativeStatus(int initNativeStatus) {
+        this.initNativeStatus = initNativeStatus;
+    }
+
+    /**
+     * 本地检测初始化，模型加载标识
+     */
+    private int initNativeStatus = NATIVE_AUTH_INIT_SUCCESS;
+
+    @IntDef({ORIENTATION_PORTRAIT, ORIENTATION_HORIZONTAL, ORIENTATION_INVERT})
+    public @interface Orientation {
+
+    }
+
+    private CameraViewTakePictureCallback cameraViewTakePictureCallback = new CameraViewTakePictureCallback();
+
+    private ICameraControl cameraControl;
+
+    /**
+     * 相机预览View
+     */
+    private View displayView;
+    /**
+     * 身份证，银行卡，等裁剪用的遮罩
+     */
+    private MaskView maskView;
+
+    /**
+     * 用于显示提示证 "请对齐身份证正面" 之类的背景
+     */
+    private ImageView hintView;
+
+    /**
+     * 用于显示提示证 "请对齐身份证正面" 之类的文字
+     */
+    private TextView hintViewText;
+
+    /**
+     * 提示文案容器
+     */
+    private LinearLayout hintViewTextWrapper;
+
+    /**
+     * 是否是本地质量控制扫描
+     */
+    private boolean isEnableScan;
+
+    public void setEnableScan(boolean enableScan) {
+        isEnableScan = enableScan;
+    }
+
+    /**
+     * UI线程的handler
+     */
+    Handler uiHandler = new Handler(Looper.getMainLooper());
+
+    public ICameraControl getCameraControl() {
+        return cameraControl;
+    }
+
+    public void setOrientation(@Orientation int orientation) {
+        cameraControl.setDisplayOrientation(orientation);
+    }
+
+    public CameraView(Context context) {
+        super(context);
+        init();
+    }
+
+    public CameraView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public CameraView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    public void start() {
+        cameraControl.start();
+        setKeepScreenOn(true);
+    }
+
+    public void stop() {
+        cameraControl.stop();
+        setKeepScreenOn(false);
+    }
+
+    public void takePicture(final File file, final OnTakePictureCallback callback) {
+        cameraViewTakePictureCallback.file = file;
+        cameraViewTakePictureCallback.callback = callback;
+        cameraControl.takePicture(cameraViewTakePictureCallback);
+    }
+
+    private OnTakePictureCallback autoPictureCallback;
+
+    public void setAutoPictureCallback(OnTakePictureCallback callback) {
+        autoPictureCallback = callback;
+    }
+
+    public void setMaskType(@MaskView.MaskType int maskType, final Context ctx) {
+        maskView.setMaskType(maskType);
+
+        maskView.setVisibility(VISIBLE);
+        hintView.setVisibility(VISIBLE);
+
+        int hintResourceId = R.drawable.bd_ocr_hint_align_id_card;
+        this.maskType = maskType;
+        boolean isNeedSetImage = true;
+        switch (maskType) {
+            case MaskView.MASK_TYPE_ID_CARD_FRONT:
+                hintResourceId = R.drawable.bd_ocr_round_corner;
+                isNeedSetImage = false;
+                break;
+            case MaskView.MASK_TYPE_ID_CARD_BACK:
+                isNeedSetImage = false;
+                hintResourceId = R.drawable.bd_ocr_round_corner;
+                break;
+            case MaskView.MASK_TYPE_BANK_CARD:
+                hintResourceId = R.drawable.bd_ocr_hint_align_bank_card;
+                break;
+            case MaskView.MASK_TYPE_NONE:
+            default:
+                maskView.setVisibility(INVISIBLE);
+                hintView.setVisibility(INVISIBLE);
+                break;
+        }
+
+        if (isNeedSetImage) {
+            hintView.setImageResource(hintResourceId);
+            hintViewTextWrapper.setVisibility(INVISIBLE);
+        }
+
+        if (maskType == MaskView.MASK_TYPE_ID_CARD_FRONT && isEnableScan) {
+            cameraControl.setDetectCallback(new ICameraControl.OnDetectPictureCallback() {
+                @Override
+                public int onDetect(byte[] data, int rotation) {
+                    return detect(data, rotation);
+                }
+            });
+        }
+
+        if (maskType == MaskView.MASK_TYPE_ID_CARD_BACK && isEnableScan) {
+            cameraControl.setDetectCallback(new ICameraControl.OnDetectPictureCallback() {
+                @Override
+                public int onDetect(byte[] data, int rotation) {
+                    return detect(data, rotation);
+                }
+            });
+        }
+    }
+
+    private int detect(byte[] data, final int rotation) {
+        if (initNativeStatus != NATIVE_AUTH_INIT_SUCCESS) {
+            showTipMessage(initNativeStatus);
+            return 1;
+        }
+        // 扫描成功阻止多余的操作
+        if (cameraControl.getAbortingScan().get()) {
+            return 0;
+        }
+        // BitmapRegionDecoder不会将整个图片加载到内存。
+        BitmapRegionDecoder decoder = null;
+        try {
+            decoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
+        } catch (IOException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+
+        Rect previewFrame = cameraControl.getPreviewFrame();
+
+        int width = rotation % 180 == 0 ? decoder.getWidth() : decoder.getHeight();
+        int height = rotation % 180 == 0 ? decoder.getHeight() : decoder.getWidth();
+
+        Rect frameRect = maskView.getFrameRectExtend();
+
+        int left = width * frameRect.left / maskView.getWidth();
+        int top = height * frameRect.top / maskView.getHeight();
+        int right = width * frameRect.right / maskView.getWidth();
+        int bottom = height * frameRect.bottom / maskView.getHeight();
+
+        // 高度大于图片
+        if (previewFrame.top < 0) {
+            // 宽度对齐。
+            int adjustedPreviewHeight = previewFrame.height() * getWidth() / previewFrame.width();
+            int topInFrame = ((adjustedPreviewHeight - frameRect.height()) / 2)
+                    * getWidth() / previewFrame.width();
+            int bottomInFrame = ((adjustedPreviewHeight + frameRect.height()) / 2) * getWidth()
+                    / previewFrame.width();
+
+            // 等比例投射到照片当中。
+            top = topInFrame * height / previewFrame.height();
+            bottom = bottomInFrame * height / previewFrame.height();
+        } else {
+            // 宽度大于图片
+            if (previewFrame.left < 0) {
+                // 高度对齐
+                int adjustedPreviewWidth = previewFrame.width() * getHeight() / previewFrame.height();
+                int leftInFrame = ((adjustedPreviewWidth - maskView.getFrameRect().width()) / 2) * getHeight()
+                        / previewFrame.height();
+                int rightInFrame = ((adjustedPreviewWidth + maskView.getFrameRect().width()) / 2) * getHeight()
+                        / previewFrame.height();
+
+                // 等比例投射到照片当中。
+                left = leftInFrame * width / previewFrame.width();
+                right = rightInFrame * width / previewFrame.width();
+            }
+        }
+
+        Rect region = new Rect();
+        region.left = left;
+        region.top = top;
+        region.right = right;
+        region.bottom = bottom;
+
+        // 90度或者270度旋转
+        if (rotation % 180 == 90) {
+            int x = decoder.getWidth() / 2;
+            int y = decoder.getHeight() / 2;
+
+            int rotatedWidth = region.height();
+            int rotated = region.width();
+
+            // 计算，裁剪框旋转后的坐标
+            region.left = x - rotatedWidth / 2;
+            region.top = y - rotated / 2;
+            region.right = x + rotatedWidth / 2;
+            region.bottom = y + rotated / 2;
+            region.sort();
+        }
+
+        BitmapFactory.Options options = new BitmapFactory.Options();
+
+        // 最大图片大小。
+        int maxPreviewImageSize = 2560;
+        int size = Math.min(decoder.getWidth(), decoder.getHeight());
+        size = Math.min(size, maxPreviewImageSize);
+
+        options.inSampleSize = ImageUtil.calculateInSampleSize(options, size, size);
+        options.inScaled = true;
+        options.inDensity = Math.max(options.outWidth, options.outHeight);
+        options.inTargetDensity = size;
+        options.inPreferredConfig = Bitmap.Config.RGB_565;
+
+        Bitmap bitmap = decoder.decodeRegion(region, options);
+
+        if (rotation != 0) {
+            // 只能是裁剪完之后再旋转了。有没有别的更好的方案呢？
+            Matrix matrix = new Matrix();
+            matrix.postRotate(rotation);
+            Bitmap rotatedBitmap = Bitmap.createBitmap(
+                    bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
+            if (bitmap != rotatedBitmap) {
+                // 有时候 createBitmap会复用对象
+                bitmap.recycle();
+            }
+            bitmap = rotatedBitmap;
+        }
+
+        final int status;
+
+        // 调用本地质量控制请求
+        switch (maskType) {
+            case MaskView.MASK_TYPE_ID_CARD_FRONT:
+                status = IDcardQualityProcess.getInstance().idcardQualityDetectionImg(bitmap, true);
+                break;
+            case MaskView.MASK_TYPE_ID_CARD_BACK:
+                status = IDcardQualityProcess.getInstance().idcardQualityDetectionImg(bitmap, false);
+                break;
+            default:
+                status = 1;
+        }
+
+        // 当有某个扫描处理线程调用成功后，阻止其他线程继续调用本地控制代码
+        if (status == SCAN_SUCCESS) {
+            // 扫描成功阻止多线程同时回调
+            if (!cameraControl.getAbortingScan().compareAndSet(false, true)) {
+                bitmap.recycle();
+                return 0;
+            }
+            autoPictureCallback.onPictureTaken(bitmap);
+        }
+
+        showTipMessage(status);
+
+        return status;
+    }
+
+    private void showTipMessage(final int status) {
+        // 提示tip文字变化
+        uiHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                if (status == 0) {
+                    hintViewText.setVisibility(View.INVISIBLE);
+                } else if (!cameraControl.getAbortingScan().get()) {
+                    hintViewText.setVisibility(View.VISIBLE);
+                    hintViewText.setText(getScanMessage(status));
+                }
+            }
+        });
+    }
+
+    private String getScanMessage(int status) {
+        String message;
+        switch (status) {
+            case 0:
+                message = "";
+                break;
+            case 2:
+                message = "身份证模糊，请重新尝试";
+                break;
+            case 3:
+                message = "身份证反光，请重新尝试";
+                break;
+            case 4:
+                message = "请将身份证前后反转再进行识别";
+                break;
+            case 5:
+                message = "请拿稳镜头和身份证";
+                break;
+            case 6:
+                message = "请将镜头靠近身份证";
+                break;
+            case 7:
+                message = "请将身份证完整置于取景框内";
+                break;
+            case NATIVE_AUTH_FAIL:
+                message = "本地质量控制授权失败";
+                break;
+            case NATIVE_INIT_FAIL:
+                message = "本地模型加载失败";
+                break;
+            case NATIVE_SOLOAD_FAIL:
+                message = "本地SO库加载失败";
+                break;
+            case 1:
+            default:
+                message = "请将身份证置于取景框内";
+        }
+
+
+        return message;
+    }
+
+    private void init() {
+//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+//            cameraControl = new Camera2Control(getContext());
+//        } else {
+//
+//        }
+        cameraControl = new Camera1Control(getContext());
+
+        displayView = cameraControl.getDisplayView();
+        addView(displayView);
+
+        maskView = new MaskView(getContext());
+        addView(maskView);
+
+        hintView = new ImageView(getContext());
+        addView(hintView);
+
+        hintViewTextWrapper = new LinearLayout(getContext());
+        hintViewTextWrapper.setOrientation(LinearLayout.VERTICAL);
+        LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
+                PxUtil.dp2px(25));
+
+        lp.gravity = Gravity.CENTER;
+        hintViewText = new TextView(getContext());
+        hintViewText.setBackgroundResource(R.drawable.bd_ocr_round_corner);
+        hintViewText.setAlpha(0.5f);
+        hintViewText.setPadding(PxUtil.dp2px(10), 0, PxUtil.dp2px(10), 0);
+        hintViewTextWrapper.addView(hintViewText, lp);
+
+
+        hintViewText.setGravity(Gravity.CENTER);
+        hintViewText.setTextColor(Color.WHITE);
+        hintViewText.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14);
+        hintViewText.setText(getScanMessage(-1));
+
+
+        addView(hintViewTextWrapper, lp);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        displayView.layout(left, 0, right, bottom - top);
+        maskView.layout(left, 0, right, bottom - top);
+
+        int hintViewWidth = PxUtil.dp2px(250);
+        int hintViewHeight = PxUtil.dp2px(25);
+
+        int hintViewLeft = (getWidth() - hintViewWidth) / 2;
+        int hintViewTop = maskView.getFrameRect().bottom + PxUtil.dp2px(16);
+
+        hintViewTextWrapper.layout(hintViewLeft, hintViewTop,
+                hintViewLeft + hintViewWidth, hintViewTop + hintViewHeight);
+
+        hintView.layout(hintViewLeft, hintViewTop,
+                hintViewLeft + hintViewWidth, hintViewTop + hintViewHeight);
+    }
+
+    /**
+     * 拍摄后的照片。需要进行裁剪。有些手机（比如三星）不会对照片数据进行旋转，而是将旋转角度写入EXIF信息当中，
+     * 所以需要做旋转处理。
+     *
+     * @param outputFile 写入照片的文件。
+     * @param data       原始照片数据。
+     * @param rotation   照片exif中的旋转角度。
+     * @return 裁剪好的bitmap。
+     */
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    private Bitmap crop(File outputFile, byte[] data, int rotation) {
+        try {
+            // BitmapRegionDecoder不会将整个图片加载到内存。
+            BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
+
+            Rect previewFrame = cameraControl.getPreviewFrame();
+
+            int width = rotation % 180 == 0 ? decoder.getWidth() : decoder.getHeight();
+            int height = rotation % 180 == 0 ? decoder.getHeight() : decoder.getWidth();
+
+            Rect frameRect = maskView.getFrameRect();
+
+            int left = width * frameRect.left / maskView.getWidth();
+            int top = height * frameRect.top / maskView.getHeight();
+            int right = width * frameRect.right / maskView.getWidth();
+            int bottom = height * frameRect.bottom / maskView.getHeight();
+
+            // 高度大于图片
+            if (previewFrame.top < 0) {
+                // 宽度对齐。
+                int adjustedPreviewHeight = previewFrame.height() * getWidth() / previewFrame.width();
+                int topInFrame = ((adjustedPreviewHeight - frameRect.height()) / 2)
+                        * getWidth() / previewFrame.width();
+                int bottomInFrame = ((adjustedPreviewHeight + frameRect.height()) / 2) * getWidth()
+                        / previewFrame.width();
+
+                // 等比例投射到照片当中。
+                top = topInFrame * height / previewFrame.height();
+                bottom = bottomInFrame * height / previewFrame.height();
+            } else {
+                // 宽度大于图片
+                if (previewFrame.left < 0) {
+                    // 高度对齐
+                    int adjustedPreviewWidth = previewFrame.width() * getHeight() / previewFrame.height();
+                    int leftInFrame = ((adjustedPreviewWidth - maskView.getFrameRect().width()) / 2) * getHeight()
+                            / previewFrame.height();
+                    int rightInFrame = ((adjustedPreviewWidth + maskView.getFrameRect().width()) / 2) * getHeight()
+                            / previewFrame.height();
+
+                    // 等比例投射到照片当中。
+                    left = leftInFrame * width / previewFrame.width();
+                    right = rightInFrame * width / previewFrame.width();
+                }
+            }
+
+            Rect region = new Rect();
+            region.left = left;
+            region.top = top;
+            region.right = right;
+            region.bottom = bottom;
+
+            // 90度或者270度旋转
+            if (rotation % 180 == 90) {
+                int x = decoder.getWidth() / 2;
+                int y = decoder.getHeight() / 2;
+
+                int rotatedWidth = region.height();
+                int rotated = region.width();
+
+                // 计算，裁剪框旋转后的坐标
+                region.left = x - rotatedWidth / 2;
+                region.top = y - rotated / 2;
+                region.right = x + rotatedWidth / 2;
+                region.bottom = y + rotated / 2;
+                region.sort();
+            }
+
+            BitmapFactory.Options options = new BitmapFactory.Options();
+
+            // 最大图片大小。
+            int maxPreviewImageSize = 2560;
+            int size = Math.min(decoder.getWidth(), decoder.getHeight());
+            size = Math.min(size, maxPreviewImageSize);
+
+            options.inSampleSize = ImageUtil.calculateInSampleSize(options, size, size);
+            options.inScaled = true;
+            options.inDensity = Math.max(options.outWidth, options.outHeight);
+            options.inTargetDensity = size;
+            options.inPreferredConfig = Bitmap.Config.RGB_565;
+            Bitmap bitmap = decoder.decodeRegion(region, options);
+
+            if (rotation != 0) {
+                // 只能是裁剪完之后再旋转了。有没有别的更好的方案呢？
+                Matrix matrix = new Matrix();
+                matrix.postRotate(rotation);
+                Bitmap rotatedBitmap = Bitmap.createBitmap(
+                        bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
+                if (bitmap != rotatedBitmap) {
+                    // 有时候 createBitmap会复用对象
+                    bitmap.recycle();
+                }
+                bitmap = rotatedBitmap;
+            }
+
+            try {
+                if (!outputFile.exists()) {
+                    outputFile.createNewFile();
+                }
+                FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
+                bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fileOutputStream);
+                fileOutputStream.flush();
+                fileOutputStream.close();
+                return bitmap;
+            } catch (IOException e) {
+                if (e!=null)
+                e.printStackTrace();
+            }
+        } catch (IOException e) {
+            if (e!=null)
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public void release() {
+        IDcardQualityProcess.getInstance().releaseModel();
+    }
+
+    private class CameraViewTakePictureCallback implements ICameraControl.OnTakePictureCallback {
+
+        private File file;
+        private OnTakePictureCallback callback;
+
+        @Override
+        public void onPictureTaken(final byte[] data) {
+            CameraThreadPool.execute(new Runnable() {
+                @Override
+                public void run() {
+                    final int rotation = ImageUtil.getOrientation(data);
+                    Bitmap bitmap = crop(file, data, rotation);
+                    callback.onPictureTaken(bitmap);
+                }
+            });
+        }
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import android.graphics.Rect;
+import android.view.View;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import androidx.annotation.IntDef;
+
+/**
+ * Android 5.0 相机的API发生很大的变化。些类屏蔽掉了 api的变化。相机的操作和功能，抽象剥离出来。
+ */
+public interface ICameraControl {
+
+    /**
+     * 闪光灯关 {@link #setFlashMode(int)}
+     */
+    int FLASH_MODE_OFF = 0;
+    /**
+     * 闪光灯开 {@link #setFlashMode(int)}
+     */
+    int FLASH_MODE_TORCH = 1;
+    /**
+     * 闪光灯自动 {@link #setFlashMode(int)}
+     */
+    int FLASH_MODE_AUTO = 2;
+
+    @IntDef({FLASH_MODE_TORCH, FLASH_MODE_OFF, FLASH_MODE_AUTO})
+    @interface FlashMode {
+
+    }
+
+    /**
+     * 照相回调。
+     */
+    interface OnTakePictureCallback {
+        void onPictureTaken(byte[] data);
+    }
+
+    /**
+     * 设置本地质量控制回调，如果不设置则视为不扫描调用本地质量控制代码。
+     */
+    void setDetectCallback(OnDetectPictureCallback callback);
+
+    /**
+     * 预览回调
+     */
+    interface OnDetectPictureCallback {
+        int onDetect(byte[] data, int rotation);
+    }
+
+    /**
+     * 打开相机。
+     */
+    void start();
+
+    /**
+     * 关闭相机
+     */
+    void stop();
+
+    void pause();
+
+    void resume();
+
+    /**
+     * 相机对应的预览视图。
+     * @return 预览视图
+     */
+    View getDisplayView();
+
+    /**
+     * 看到的预览可能不是照片的全部。返回预览视图的全貌。
+     * @return 预览视图frame;
+     */
+    Rect getPreviewFrame();
+
+    /**
+     * 拍照。结果在回调中获取。
+     * @param callback 拍照结果回调
+     */
+    void takePicture(OnTakePictureCallback callback);
+
+    /**
+     * 设置权限回调，当手机没有拍照权限时，可在回调中获取。
+     * @param callback 权限回调
+     */
+    void setPermissionCallback(PermissionCallback callback);
+
+    /**
+     * 设置水平方向
+     * @param displayOrientation 参数值见 {@link com.cnlive.ocr.ui.camera.CameraView.Orientation}
+     */
+    void setDisplayOrientation(@CameraView.Orientation int displayOrientation);
+
+    /**
+     * 获取到拍照权限时，调用些函数以继续。
+     */
+    void refreshPermission();
+
+    /**
+     * 获取已经扫描成功，处理中
+     */
+    AtomicBoolean getAbortingScan();
+
+    /**
+     *  设置闪光灯状态。
+     * @param flashMode {@link #FLASH_MODE_TORCH,#FLASH_MODE_OFF,#FLASH_MODE_AUTO}
+     */
+    void setFlashMode(@FlashMode int flashMode);
+
+    /**
+     * 获取当前闪光灯状态
+     * @return 当前闪光灯状态 参见 {@link #setFlashMode(int)}
+     */
+    @FlashMode
+    int getFlashMode();
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.view.View;
+
+import com.cnlive.core.people_verfication.R;
+
+import java.io.File;
+
+import androidx.annotation.IntDef;
+import androidx.annotation.RequiresApi;
+import androidx.core.content.res.ResourcesCompat;
+
+@SuppressWarnings("unused")
+public class MaskView extends View {
+
+    public static final int MASK_TYPE_NONE = 0;
+    public static final int MASK_TYPE_ID_CARD_FRONT = 1;
+    public static final int MASK_TYPE_ID_CARD_BACK = 2;
+    public static final int MASK_TYPE_BANK_CARD = 11;
+    public static final int MASK_TYPE_AVATAR = 12;
+
+    @IntDef({MASK_TYPE_NONE, MASK_TYPE_ID_CARD_FRONT, MASK_TYPE_ID_CARD_BACK, MASK_TYPE_BANK_CARD, MASK_TYPE_AVATAR})
+    @interface MaskType {
+
+    }
+
+    public void setLineColor(int lineColor) {
+        this.lineColor = lineColor;
+    }
+
+    public void setMaskColor(int maskColor) {
+        this.maskColor = maskColor;
+    }
+
+    private int lineColor = Color.WHITE;
+
+    private int maskType = MASK_TYPE_ID_CARD_FRONT;
+
+    private int maskColor = Color.argb(100, 0, 0, 0);
+
+    private Paint eraser = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private Paint pen = new Paint(Paint.ANTI_ALIAS_FLAG);
+
+    private Rect frame = new Rect();
+
+    private Drawable locatorDrawable;
+
+    public Rect getFrameRect() {
+        if (maskType == MASK_TYPE_NONE) {
+            return new Rect(0, 0, getWidth(), getHeight());
+        } else {
+            return new Rect(frame);
+        }
+
+    }
+
+    public Rect getFrameRectExtend() {
+        Rect rc = new Rect(frame);
+        int widthExtend = (int) ((frame.right - frame.left) * 0.02f);
+        int heightExtend = (int) ((frame.bottom - frame.top) * 0.02f);
+        rc.left -= widthExtend;
+        rc.right += widthExtend;
+        rc.top -= heightExtend;
+        rc.bottom += heightExtend;
+        return rc;
+    }
+
+    public void setMaskType(@MaskType int maskType) {
+        this.maskType = maskType;
+        switch (maskType) {
+            case MASK_TYPE_ID_CARD_FRONT:
+                locatorDrawable = ResourcesCompat.getDrawable(getResources(),
+                        R.drawable.bd_ocr_id_card_locator_front, null);
+                break;
+            case MASK_TYPE_ID_CARD_BACK:
+                locatorDrawable = ResourcesCompat.getDrawable(getResources(),
+                        R.drawable.bd_ocr_id_card_locator_back, null);
+                break;
+            case MASK_TYPE_BANK_CARD:
+                break;
+            case MASK_TYPE_AVATAR:
+                break;
+            case MASK_TYPE_NONE:
+            default:
+                break;
+        }
+        invalidate();
+    }
+
+    public int getMaskType() {
+        return maskType;
+    }
+
+    public void setOrientation(@CameraView.Orientation int orientation) {
+    }
+
+    public MaskView(Context context) {
+        super(context);
+        init();
+    }
+
+    public MaskView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public MaskView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    private void init() {
+        locatorDrawable = ResourcesCompat.getDrawable(getResources(), R.drawable.bd_ocr_id_card_locator_front, null);
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        if (w > 0 && h > 0) {
+            float ratio = h > w ? 0.9f : 0.72f;
+
+            int width = (int) (w * ratio);
+            int height;
+            if (maskType == MASK_TYPE_AVATAR) {
+                height = width;
+            } else {
+                height = width * 400 / 620;
+            }
+
+            int left = (w - width) / 2;
+            int top = (h - height) / 2;
+            int right = width + left;
+            int bottom = height + top;
+
+            frame.left = left;
+            frame.top = top;
+            frame.right = right;
+            frame.bottom = bottom;
+
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+
+        int width = frame.width();
+        int height = frame.height();
+
+        int left = frame.left;
+        int top = frame.top;
+        int right = frame.right;
+        int bottom = frame.bottom;
+
+        canvas.drawColor(maskColor);
+        fillRectRound(left, top, right, bottom, 30, 30, false);
+        canvas.drawPath(path, pen);
+        canvas.drawPath(path, eraser);
+
+        if (maskType == MASK_TYPE_ID_CARD_FRONT) {
+            locatorDrawable.setBounds(
+                    (int) (left + 601f / 1006 * width),
+                    (int) (top + (110f / 632) * height),
+                    (int) (left + (963f / 1006) * width),
+                    (int) (top + (476f / 632) * height));
+        } else if (maskType == MASK_TYPE_ID_CARD_BACK) {
+            locatorDrawable.setBounds(
+                    (int) (left + 51f / 1006 * width),
+                    (int) (top + (48f / 632) * height),
+                    (int) (left + (250f / 1006) * width),
+                    (int) (top + (262f / 632) * height));
+        }
+        if (locatorDrawable != null) {
+            locatorDrawable.draw(canvas);
+        }
+    }
+
+    private Path path = new Path();
+
+    private Path fillRectRound(float left, float top, float right, float bottom, float rx, float ry, boolean
+            conformToOriginalPost) {
+
+        path.reset();
+        if (rx < 0) {
+            rx = 0;
+        }
+        if (ry < 0) {
+            ry = 0;
+        }
+        float width = right - left;
+        float height = bottom - top;
+        if (rx > width / 2) {
+            rx = width / 2;
+        }
+        if (ry > height / 2) {
+            ry = height / 2;
+        }
+        float widthMinusCorners = (width - (2 * rx));
+        float heightMinusCorners = (height - (2 * ry));
+
+        path.moveTo(right, top + ry);
+        path.rQuadTo(0, -ry, -rx, -ry);
+        path.rLineTo(-widthMinusCorners, 0);
+        path.rQuadTo(-rx, 0, -rx, ry);
+        path.rLineTo(0, heightMinusCorners);
+
+        if (conformToOriginalPost) {
+            path.rLineTo(0, ry);
+            path.rLineTo(width, 0);
+            path.rLineTo(0, -ry);
+        } else {
+            path.rQuadTo(0, ry, rx, ry);
+            path.rLineTo(widthMinusCorners, 0);
+            path.rQuadTo(rx, 0, rx, -ry);
+        }
+
+        path.rLineTo(0, -heightMinusCorners);
+        path.close();
+        return path;
+    }
+
+    {
+        // 硬件加速不支持，图层混合。
+        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
+
+        pen.setColor(Color.WHITE);
+        pen.setStyle(Paint.Style.STROKE);
+        pen.setStrokeWidth(6);
+
+        eraser.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
+    }
+
+    private void capture(File file) {
+
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import com.cnlive.core.people_verfication.R;
+
+
+public class OCRCameraLayout extends FrameLayout {
+
+    public static int ORIENTATION_PORTRAIT = 0;
+    public static int ORIENTATION_HORIZONTAL = 1;
+
+    private int orientation = ORIENTATION_PORTRAIT;
+    private View contentView;
+    private View centerView;
+    private View leftDownView;
+    private View rightUpView;
+
+    private int contentViewId;
+    private int centerViewId;
+    private int leftDownViewId;
+    private int rightUpViewId;
+
+    public void setOrientation(int orientation) {
+        if (this.orientation == orientation) {
+            return;
+        }
+        this.orientation = orientation;
+        requestLayout();
+    }
+
+    public OCRCameraLayout(Context context) {
+        super(context);
+    }
+
+    public OCRCameraLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        parseAttrs(attrs);
+    }
+
+    public OCRCameraLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        parseAttrs(attrs);
+    }
+
+    {
+        setWillNotDraw(false);
+    }
+
+    private void parseAttrs(AttributeSet attrs) {
+        TypedArray a = getContext().getTheme().obtainStyledAttributes(
+                attrs,
+                R.styleable.OCRCameraLayout,
+                0, 0);
+        try {
+            contentViewId = a.getResourceId(R.styleable.OCRCameraLayout_contentView, -1);
+            centerViewId = a.getResourceId(R.styleable.OCRCameraLayout_centerView, -1);
+            leftDownViewId = a.getResourceId(R.styleable.OCRCameraLayout_leftDownView, -1);
+            rightUpViewId = a.getResourceId(R.styleable.OCRCameraLayout_rightUpView, -1);
+        } finally {
+            a.recycle();
+        }
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        contentView = findViewById(contentViewId);
+        if (centerViewId != -1) {
+            centerView = findViewById(centerViewId);
+        }
+        leftDownView = findViewById(leftDownViewId);
+        rightUpView = findViewById(rightUpViewId);
+    }
+
+    private Rect backgroundRect = new Rect();
+    private Paint paint = new Paint();
+
+    {
+        paint.setStyle(Paint.Style.FILL);
+        paint.setColor(Color.argb(83, 0, 0, 0));
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        int width = getWidth();
+        int height = getHeight();
+        int left;
+        int top;
+
+        MarginLayoutParams leftDownViewLayoutParams = (MarginLayoutParams) leftDownView.getLayoutParams();
+        MarginLayoutParams rightUpViewLayoutParams = (MarginLayoutParams) rightUpView.getLayoutParams();
+        if (r < b) {
+            int contentHeight = width * 4 / 3;
+            int heightLeft = height - contentHeight;
+            contentView.layout(l, t, r, contentHeight);
+
+            backgroundRect.left = 0;
+            backgroundRect.top = contentHeight;
+            backgroundRect.right = width;
+            backgroundRect.bottom = height;
+
+            // layout centerView;
+            if (centerView != null) {
+                left = (width - centerView.getMeasuredWidth()) / 2;
+                top = contentHeight + (heightLeft - centerView.getMeasuredHeight()) / 2;
+                centerView
+                        .layout(left, top, left + centerView.getMeasuredWidth(), top + centerView.getMeasuredHeight());
+            }
+            // layout leftDownView
+
+            left = leftDownViewLayoutParams.leftMargin;
+            top = contentHeight + (heightLeft - leftDownView.getMeasuredHeight()) / 2;
+            leftDownView
+                    .layout(left, top, left + leftDownView.getMeasuredWidth(), top + leftDownView.getMeasuredHeight());
+            // layout rightUpView
+            left = width - rightUpView.getMeasuredWidth() - rightUpViewLayoutParams.rightMargin;
+            top = contentHeight + (heightLeft - rightUpView.getMeasuredHeight()) / 2;
+            rightUpView.layout(left, top, left + rightUpView.getMeasuredWidth(), top + rightUpView.getMeasuredHeight());
+        } else {
+            int contentWidth = height * 4 / 3;
+            int widthLeft = width - contentWidth;
+            contentView.layout(l, t, contentWidth, height);
+
+            backgroundRect.left = contentWidth;
+            backgroundRect.top = 0;
+            backgroundRect.right = width;
+            backgroundRect.bottom = height;
+
+            // layout centerView
+            if (centerView != null) {
+                left = contentWidth + (widthLeft - centerView.getMeasuredWidth()) / 2;
+                top = (height - centerView.getMeasuredHeight()) / 2;
+                centerView
+                        .layout(left, top, left + centerView.getMeasuredWidth(), top + centerView.getMeasuredHeight());
+            }
+            // layout leftDownView
+            left = contentWidth + (widthLeft - leftDownView.getMeasuredWidth()) / 2;
+            top = height - leftDownView.getMeasuredHeight() - leftDownViewLayoutParams.bottomMargin;
+            leftDownView
+                    .layout(left, top, left + leftDownView.getMeasuredWidth(), top + leftDownView.getMeasuredHeight());
+            // layout rightUpView
+            left = contentWidth + (widthLeft - rightUpView.getMeasuredWidth()) / 2;
+
+            top = rightUpViewLayoutParams.topMargin;
+            rightUpView.layout(left, top, left + rightUpView.getMeasuredWidth(), top + rightUpView.getMeasuredHeight());
+        }
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        canvas.drawRect(backgroundRect, paint);
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+
+public class OCRFrameLayout extends ViewGroup {
+
+    public OCRFrameLayout(Context context) {
+        super(context);
+    }
+
+    public OCRFrameLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        parseAttrs(attrs);
+    }
+
+    public OCRFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        parseAttrs(attrs);
+    }
+
+    private void parseAttrs(AttributeSet attrs) {
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            View view = getChildAt(i);
+            view.layout(l, t, r, b);
+        }
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        int width;
+        int height;
+        int childCount = getChildCount();
+
+        width = MeasureSpec.getSize(widthMeasureSpec);
+        height = MeasureSpec.getSize(heightMeasureSpec);
+        for (int i = 0; i < childCount; i++) {
+            View view = getChildAt(i);
+            measureChild(view, MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec
+                    (height, MeasureSpec.EXACTLY));
+        }
+        setMeasuredDimension(resolveSize(width, widthMeasureSpec), resolveSize(height, heightMeasureSpec));
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.camera;
+
+public interface PermissionCallback {
+    boolean onRequestPermission();
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.crop;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.media.ExifInterface;
+import android.util.AttributeSet;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.ScaleGestureDetector;
+import android.view.View;
+import android.view.WindowManager;
+
+import com.cnlive.core.libs.base.util.AlertUtil;
+import com.cnlive.core.ocr.ui.util.ImageUtil;
+
+import java.io.IOException;
+
+public class CropView extends View {
+
+    public CropView(Context context) {
+        super(context);
+        init();
+    }
+
+    public CropView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public CropView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    public void setFilePath(String path) {
+
+        if (this.bitmap != null && !this.bitmap.isRecycled()) {
+            this.bitmap.recycle();
+        }
+
+        if (path == null) {
+            return;
+        }
+
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inJustDecodeBounds = true;
+        Bitmap original = BitmapFactory.decodeFile(path, options);
+
+        try {
+            ExifInterface exif = new ExifInterface(path);
+            int rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
+            Matrix matrix = new Matrix();
+            int rotationInDegrees = ImageUtil.exifToDegrees(rotation);
+            if (rotation != 0f) {
+                matrix.preRotate(rotationInDegrees);
+            }
+
+            // 图片太大会导致内存泄露，所以在显示前对图片进行裁剪。
+            int maxPreviewImageSize = 2560;
+
+            int min = Math.min(options.outWidth, options.outHeight);
+            min = Math.min(min, maxPreviewImageSize);
+
+            WindowManager windowManager = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
+            Point screenSize = new Point();
+            windowManager.getDefaultDisplay().getSize(screenSize);
+            min = Math.min(min, screenSize.x * 2 / 3);
+
+            options.inSampleSize = ImageUtil.calculateInSampleSize(options, min, min);
+            options.inScaled = true;
+            options.inDensity = options.outWidth;
+            options.inTargetDensity = min * options.inSampleSize;
+            options.inPreferredConfig = Bitmap.Config.RGB_565;
+
+            options.inJustDecodeBounds = false;
+            this.bitmap = BitmapFactory.decodeFile(path, options);
+        } catch (IOException e) {
+            e.printStackTrace();
+            this.bitmap = original;
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+        }
+        setBitmap(this.bitmap);
+    }
+
+    private void setBitmap(Bitmap bitmap) {
+        this.bitmap = bitmap;
+        matrix.reset();
+        centerImage(getWidth(), getHeight());
+        rotation = 0;
+        invalidate();
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        centerImage(w, h);
+        invalidate();
+    }
+
+    public Bitmap crop(Rect frame) {
+        float scale = getScale();
+
+        float[] src = new float[] {frame.left, frame.top};
+        float[] desc = new float[] {0, 0};
+
+        Matrix invertedMatrix = new Matrix();
+        this.matrix.invert(invertedMatrix);
+        invertedMatrix.mapPoints(desc, src);
+
+        Matrix matrix = new Matrix();
+
+        int width = (int) (frame.width() / scale);
+        int height = (int) (frame.height() / scale);
+        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
+        Canvas canvas = new Canvas(bitmap);
+
+        Bitmap originalBitmap = this.bitmap;
+        if(originalBitmap == null){
+            AlertUtil.showDeftToast(getContext(),"该照片已失效,请重新选择");
+            return null;
+        }
+        matrix.postTranslate(-desc[0], -desc[1]);
+        canvas.drawBitmap(originalBitmap, matrix, null);
+        return bitmap;
+    }
+
+    public void setMinimumScale(float setMinimumScale) {
+        this.setMinimumScale = setMinimumScale;
+    }
+
+    public void setMaximumScale(float maximumScale) {
+        this.maximumScale = maximumScale;
+    }
+
+    private float setMinimumScale = 0.2f;
+    private float maximumScale = 4.0f;
+
+    private float[] matrixArray = new float[9];
+    private Matrix matrix = new Matrix();
+    private Bitmap bitmap;
+
+    private GestureDetector gestureDetector;
+
+    private ScaleGestureDetector scaleGestureDetector;
+    private ScaleGestureDetector.OnScaleGestureListener onScaleGestureListener =
+            new ScaleGestureDetector.OnScaleGestureListener() {
+                @Override
+                public boolean onScale(ScaleGestureDetector detector) {
+                    scale(detector);
+                    return true;
+                }
+
+                @Override
+                public boolean onScaleBegin(ScaleGestureDetector detector) {
+                    return true;
+                }
+
+                @Override
+                public void onScaleEnd(ScaleGestureDetector detector) {
+                    float scale = detector.getScaleFactor();
+                    matrix.postScale(scale, scale);
+                    invalidate();
+                }
+            };
+
+    private void init() {
+        scaleGestureDetector = new ScaleGestureDetector(getContext(), onScaleGestureListener);
+        gestureDetector = new GestureDetector(getContext(), new GestureDetector.OnGestureListener() {
+            @Override
+            public boolean onDown(MotionEvent e) {
+                return true;
+            }
+
+            @Override
+            public void onShowPress(MotionEvent e) {
+            }
+
+            @Override
+            public boolean onSingleTapUp(MotionEvent e) {
+                return false;
+            }
+
+            @Override
+            public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+                translate(distanceX, distanceY);
+                return true;
+            }
+
+            @Override
+            public void onLongPress(MotionEvent e) {
+            }
+
+            @Override
+            public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+                return false;
+            }
+        });
+    }
+
+    int rotation = 0;
+
+    public void rotate(int degrees) {
+        Matrix matrix = new Matrix();
+
+        if(bitmap == null) return;
+        int dx = this.bitmap.getWidth() / 2;
+        int dy = this.bitmap.getHeight() / 2;
+
+        matrix.postTranslate(-dx, -dy);
+        matrix.postRotate(degrees);
+        matrix.postTranslate(dy, dx);
+        Bitmap scaledBitmap = this.bitmap;
+        Bitmap rotatedBitmap = Bitmap.createBitmap(scaledBitmap.getHeight(), scaledBitmap.getWidth(),
+                Bitmap.Config.RGB_565);
+        Canvas canvas = new Canvas(rotatedBitmap);
+        canvas.drawBitmap(this.bitmap, matrix, null);
+        this.bitmap.recycle();
+        this.bitmap = rotatedBitmap;
+        centerImage(getWidth(), getHeight());
+        invalidate();
+    }
+
+    private void translate(float distanceX, float distanceY) {
+        matrix.getValues(matrixArray);
+        float left = matrixArray[Matrix.MTRANS_X];
+        float top = matrixArray[Matrix.MTRANS_Y];
+
+        Rect bound = getRestrictedBound();
+        if (bound != null) {
+            float scale = getScale();
+            float right = left + (int) (bitmap.getWidth() / scale);
+            float bottom = top + (int) (bitmap.getHeight() / scale);
+
+            if (left - distanceX > bound.left) {
+                distanceX = left - bound.left;
+            }
+            if (top - distanceY > bound.top) {
+                distanceY = top - bound.top;
+            }
+
+            if (distanceX > 0) {
+                if (right - distanceX < bound.right) {
+                    distanceX = right - bound.right;
+                }
+            }
+            if (distanceY > 0) {
+                if (bottom - distanceY < bound.bottom) {
+                    distanceY = bottom - bound.bottom;
+                }
+            }
+        }
+        matrix.postTranslate(-distanceX, -distanceY);
+        invalidate();
+    }
+
+    private void scale(ScaleGestureDetector detector) {
+        float scale = detector.getScaleFactor();
+        float currentScale = getScale();
+        if (currentScale * scale < setMinimumScale) {
+            scale = setMinimumScale / currentScale;
+        }
+        if (currentScale * scale > maximumScale) {
+            scale = maximumScale / currentScale;
+        }
+        matrix.postScale(scale, scale, detector.getFocusX(), detector.getFocusY());
+        invalidate();
+    }
+
+    private void centerImage(int width, int height) {
+        if (width <= 0 || height <= 0 || bitmap == null) {
+            return;
+        }
+        float widthRatio = 1.0f * height / this.bitmap.getHeight();
+        float heightRatio = 1.0f * width / this.bitmap.getWidth();
+
+        float ratio = Math.min(widthRatio, heightRatio);
+
+        float dx = (width - this.bitmap.getWidth()) / 2;
+        float dy = (height - this.bitmap.getHeight()) / 2;
+        matrix.setTranslate(0, 0);
+        matrix.setScale(ratio, ratio, bitmap.getWidth() / 2, bitmap.getHeight() / 2);
+        matrix.postTranslate(dx, dy);
+        invalidate();
+    }
+
+    private float getScale() {
+        matrix.getValues(matrixArray);
+        float scale = matrixArray[Matrix.MSCALE_X];
+        if (Math.abs(scale) <= 0.1) {
+            scale = matrixArray[Matrix.MSKEW_X];
+        }
+        return Math.abs(scale);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        if (bitmap != null) {
+            canvas.drawBitmap(bitmap, matrix, null);
+        }
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        boolean result = scaleGestureDetector.onTouchEvent(event);
+        result = gestureDetector.onTouchEvent(event) || result;
+        return result || super.onTouchEvent(event);
+    }
+
+    private Rect restrictBound;
+
+    private Rect getRestrictedBound() {
+        return restrictBound;
+    }
+
+    public void setRestrictBound(Rect rect) {
+        this.restrictBound = rect;
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.crop;
+
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.View;
+
+import com.cnlive.core.ocr.ui.util.PxUtil;
+
+
+public class FrameOverlayView extends View {
+
+    interface OnFrameChangeListener {
+        void onFrameChange(RectF newFrame);
+    }
+
+    public Rect getFrameRect() {
+        Rect rect = new Rect();
+        rect.left = (int) frameRect.left;
+        rect.top = (int) frameRect.top;
+        rect.right = (int) frameRect.right;
+        rect.bottom = (int) frameRect.bottom;
+        return rect;
+    }
+
+    public FrameOverlayView(Context context) {
+        super(context);
+        init();
+    }
+
+    public FrameOverlayView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public FrameOverlayView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    private GestureDetector.SimpleOnGestureListener onGestureListener = new GestureDetector.SimpleOnGestureListener() {
+        @Override
+        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+            translate(distanceX, distanceY);
+            return true;
+        }
+
+    };
+
+    private static final int CORNER_LEFT_TOP = 1;
+    private static final int CORNER_RIGHT_TOP = 2;
+    private static final int CORNER_RIGHT_BOTTOM = 3;
+    private static final int CORNER_LEFT_BOTTOM = 4;
+
+    private int currentCorner = -1;
+    int margin = 20;
+    int cornerLength = 100;
+    int cornerLineWidth = 6;
+
+    private int maskColor = Color.argb(180, 0, 0, 0);
+
+    private Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private Paint eraser = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private GestureDetector gestureDetector;
+    private RectF touchRect = new RectF();
+    private RectF frameRect = new RectF();
+
+    private OnFrameChangeListener onFrameChangeListener;
+
+    {
+        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
+        paint.setColor(Color.WHITE);
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setStrokeWidth(6);
+
+        eraser.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
+    }
+
+    public void setOnFrameChangeListener(OnFrameChangeListener onFrameChangeListener) {
+        this.onFrameChangeListener = onFrameChangeListener;
+    }
+
+    private void init() {
+        gestureDetector = new GestureDetector(getContext(), onGestureListener);
+        cornerLength = PxUtil.dp2px(18);
+        cornerLineWidth = PxUtil.dp2px(3);
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        resetFrameRect(w, h);
+    }
+
+    private void resetFrameRect(int w, int h) {
+        if (shapeType == 1) {
+            frameRect.left = (int) (w * 0.05);
+            frameRect.top = (int) (h * 0.25);
+        } else {
+            frameRect.left = (int) (w * 0.2);
+            frameRect.top = (int) (h * 0.2);
+        }
+        frameRect.right = w - frameRect.left;
+        frameRect.bottom = h - frameRect.top;
+    }
+
+    private int shapeType = 0;
+
+    public void setTypeWide() {
+        shapeType = 1;
+    }
+
+    private void translate(float x, float y) {
+        if (x > 0) {
+            // moving left;
+            if (frameRect.left - x < margin) {
+                x = frameRect.left - margin;
+            }
+        } else {
+            if (frameRect.right - x > getWidth() - margin) {
+                x = frameRect.right - getWidth() + margin;
+            }
+        }
+
+        if (y > 0) {
+            if (frameRect.top - y < margin) {
+                y = frameRect.top - margin;
+            }
+        } else {
+            if (frameRect.bottom - y > getHeight() - margin) {
+                y = frameRect.bottom - getHeight() + margin;
+            }
+        }
+        frameRect.offset(-x, -y);
+        invalidate();
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+
+        canvas.drawColor(maskColor);
+
+        paint.setStrokeWidth(PxUtil.dp2px(1));
+        canvas.drawRect(frameRect, paint);
+        canvas.drawRect(frameRect, eraser);
+        drawCorners(canvas);
+    }
+
+    private void drawCorners(Canvas canvas) {
+        paint.setStrokeWidth(cornerLineWidth);
+        // left top
+        drawLine(canvas, frameRect.left - cornerLineWidth / 2, frameRect.top, cornerLength, 0);
+        drawLine(canvas, frameRect.left, frameRect.top, 0, cornerLength);
+
+        // right top
+        drawLine(canvas, frameRect.right + cornerLineWidth / 2, frameRect.top, -cornerLength, 0);
+        drawLine(canvas, frameRect.right, frameRect.top, 0, cornerLength);
+
+        // right bottom
+        drawLine(canvas, frameRect.right, frameRect.bottom, 0, -cornerLength);
+        drawLine(canvas, frameRect.right + cornerLineWidth / 2, frameRect.bottom, -cornerLength, 0);
+
+        // left bottom
+        drawLine(canvas, frameRect.left - cornerLineWidth / 2, frameRect.bottom, cornerLength, 0);
+        drawLine(canvas, frameRect.left, frameRect.bottom, 0, -cornerLength);
+    }
+
+    private void drawLine(Canvas canvas, float x, float y, int dx, int dy) {
+        canvas.drawLine(x, y, x + dx, y + dy, paint);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        boolean result = handleDown(event);
+        float ex = 60;
+        RectF rectExtend = new RectF(frameRect.left - ex, frameRect.top - ex,
+                frameRect.right + ex, frameRect.bottom + ex);
+        if (!result) {
+            if (rectExtend.contains(event.getX(), event.getY())) {
+                gestureDetector.onTouchEvent(event);
+                return true;
+            }
+        }
+        return result;
+    }
+
+    private boolean handleDown(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+                currentCorner = -1;
+                break;
+            case MotionEvent.ACTION_DOWN: {
+                float radius = cornerLength;
+                touchRect.set(event.getX() - radius, event.getY() - radius, event.getX() + radius,
+                        event.getY() + radius);
+                if (touchRect.contains(frameRect.left, frameRect.top)) {
+                    currentCorner = CORNER_LEFT_TOP;
+                    return true;
+                }
+
+                if (touchRect.contains(frameRect.right, frameRect.top)) {
+                    currentCorner = CORNER_RIGHT_TOP;
+                    return true;
+                }
+
+                if (touchRect.contains(frameRect.right, frameRect.bottom)) {
+                    currentCorner = CORNER_RIGHT_BOTTOM;
+                    return true;
+                }
+
+                if (touchRect.contains(frameRect.left, frameRect.bottom)) {
+                    currentCorner = CORNER_LEFT_BOTTOM;
+                    return true;
+                }
+                return false;
+            }
+            case MotionEvent.ACTION_MOVE:
+                return handleScale(event);
+            default:
+
+        }
+        return false;
+    }
+
+    private boolean handleScale(MotionEvent event) {
+        switch (currentCorner) {
+            case CORNER_LEFT_TOP:
+                scaleTo(event.getX(), event.getY(), frameRect.right, frameRect.bottom);
+                return true;
+            case CORNER_RIGHT_TOP:
+                scaleTo(frameRect.left, event.getY(), event.getX(), frameRect.bottom);
+                return true;
+            case CORNER_RIGHT_BOTTOM:
+                scaleTo(frameRect.left, frameRect.top, event.getX(), event.getY());
+                return true;
+            case CORNER_LEFT_BOTTOM:
+                scaleTo(event.getX(), frameRect.top, frameRect.right, event.getY());
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private void scaleTo(float left, float top, float right, float bottom) {
+        if (bottom - top < getMinimumFrameHeight()) {
+            top = frameRect.top;
+            bottom = frameRect.bottom;
+        }
+        if (right - left < getMinimumFrameWidth()) {
+            left = frameRect.left;
+            right = frameRect.right;
+        }
+        left = Math.max(margin, left);
+        top = Math.max(margin, top);
+        right = Math.min(getWidth() - margin, right);
+        bottom = Math.min(getHeight() - margin, bottom);
+
+        frameRect.set(left, top, right, bottom);
+        invalidate();
+    }
+
+
+    private void notifyFrameChange() {
+        if (onFrameChangeListener != null) {
+            onFrameChangeListener.onFrameChange(frameRect);
+        }
+    }
+
+    private float getMinimumFrameWidth() {
+        return 2.4f * cornerLength;
+    }
+
+    private float getMinimumFrameHeight() {
+        return 2.4f * cornerLength;
+    }
+}
+/*
+ * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
+ */
+package com.cnlive.core.ocr.ui.util;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Rect;
+import android.media.ExifInterface;
+import android.util.Log;
+
+public class ImageUtil {
+    private static final String TAG = "CameraExif";
+
+    public static int exifToDegrees(int exifOrientation) {
+        if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) {
+            return 90;
+        } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) {
+            return 180;
+        } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) {
+            return 270;
+        }
+        return 0;
+    }
+
+    // Returns the degrees in clockwise. Values are 0, 90, 180, or 270.
+    public static int getOrientation(byte[] jpeg) {
+        if (jpeg == null) {
+            return 0;
+        }
+
+        int offset = 0;
+        int length = 0;
+
+        // ISO/IEC 10918-1:1993(E)
+        while (offset + 3 < jpeg.length && (jpeg[offset++] & 0xFF) == 0xFF) {
+            int marker = jpeg[offset] & 0xFF;
+
+            // Check if the marker is a padding.
+            if (marker == 0xFF) {
+                continue;
+            }
+            offset++;
+
+            // Check if the marker is SOI or TEM.
+            if (marker == 0xD8 || marker == 0x01) {
+                continue;
+            }
+            // Check if the marker is EOI or SOS.
+            if (marker == 0xD9 || marker == 0xDA) {
+                break;
+            }
+
+            // Get the length and check if it is reasonable.
+            length = pack(jpeg, offset, 2, false);
+            if (length < 2 || offset + length > jpeg.length) {
+                Log.e(TAG, "Invalid length");
+                return 0;
+            }
+
+            // Break if the marker is EXIF in APP1.
+            if (marker == 0xE1 && length >= 8
+                    && pack(jpeg, offset + 2, 4, false) == 0x45786966
+                    && pack(jpeg, offset + 6, 2, false) == 0) {
+                offset += 8;
+                length -= 8;
+                break;
+            }
+
+            // Skip other markers.
+            offset += length;
+            length = 0;
+        }
+
+        // JEITA CP-3451 Exif Version 2.2
+        if (length > 8) {
+            // Identify the byte order.
+            int tag = pack(jpeg, offset, 4, false);
+            if (tag != 0x49492A00 && tag != 0x4D4D002A) {
+                Log.e(TAG, "Invalid byte order");
+                return 0;
+            }
+            boolean littleEndian = (tag == 0x49492A00);
+
+            // Get the offset and check if it is reasonable.
+            int count = pack(jpeg, offset + 4, 4, littleEndian) + 2;
+            if (count < 10 || count > length) {
+                Log.e(TAG, "Invalid offset");
+                return 0;
+            }
+            offset += count;
+            length -= count;
+
+            // Get the count and go through all the elements.
+            count = pack(jpeg, offset - 2, 2, littleEndian);
+            while (count-- > 0 && length >= 12) {
+                // Get the tag and check if it is orientation.
+                tag = pack(jpeg, offset, 2, littleEndian);
+                if (tag == 0x0112) {
+                    // We do not really care about type and count, do we?
+                    int orientation = pack(jpeg, offset + 8, 2, littleEndian);
+                    switch (orientation) {
+                        case 1:
+                            return 0;
+                        case 3:
+                            return 180;
+                        case 6:
+                            return 90;
+                        case 8:
+                            return 270;
+                        default:
+                            return 0;
+                    }
+                }
+                offset += 12;
+                length -= 12;
+            }
+        }
+
+        Log.i(TAG, "Orientation not found");
+        return 0;
+    }
+
+    private static int pack(byte[] bytes, int offset, int length,
+                            boolean littleEndian) {
+        int step = 1;
+        if (littleEndian) {
+            offset += length - 1;
+            step = -1;
+        }
+
+        int value = 0;
+        while (length-- > 0) {
+            value = (value << 8) | (bytes[offset] & 0xFF);
+            offset += step;
+        }
+        return value;
+    }
+
+
+    public static int calculateInSampleSize(
+            BitmapFactory.Options options, int reqWidth, int reqHeight) {
+        // Raw height and width of image
+        final int height = options.outHeight;
+        final int width = options.outWidth;
+        int inSampleSize = 1;
+
+        if (height > reqHeight || width > reqWidth) {
+
+            final int halfHeight = height / 2;
+            final int halfWidth = width / 2;
+            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
+            // height and width larger than the requested height and width.
+            while ((halfHeight / inSampleSize) >= reqHeight
+                    && (halfWidth / inSampleSize) >= reqWidth) {
+                inSampleSize *= 2;
+            }
+        }
+
+        return inSampleSize;
+    }
+
+    /**
+     * 绘制文字到右下角
+     *
+     * @param context
+     * @param bitmap
+     * @param text
+     * @param size
+     * @param color
+     * @param paddingRight
+     * @param paddingBottom
+     * @return
+     */
+    public static Bitmap drawTextToRightBottom(Context context, Bitmap bitmap, String text,
+                                               int size, int color, int paddingRight, int paddingBottom) {
+        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+        paint.setColor(color);
+        paint.setTextSize(dp2px(context, size));
+        Rect bounds = new Rect();
+        paint.getTextBounds(text, 0, text.length(), bounds);
+        return drawTextToBitmap(context, bitmap, text, paint, bounds,
+                bitmap.getWidth() - bounds.width() - dp2px(context, paddingRight),
+                bitmap.getHeight() - dp2px(context, paddingBottom));
+    }
+
+    //图片上绘制文字
+    private static Bitmap drawTextToBitmap(Context context, Bitmap bitmap, String text,
+                                           Paint paint, Rect bounds, int paddingLeft, int paddingTop) {
+        Bitmap.Config bitmapConfig = bitmap.getConfig();
+
+        paint.setDither(true); // 获取跟清晰的图像采样
+        paint.setFilterBitmap(true);// 过滤一些
+        if (bitmapConfig == null) {
+            bitmapConfig = Bitmap.Config.ARGB_8888;
+        }
+        bitmap = bitmap.copy(bitmapConfig, true);
+        Canvas canvas = new Canvas(bitmap);
+//        canvas.rotate(-45);
+//        canvas.drawText(text, paddingLeft, paddingTop, paint);
+
+        Path path = new Path();
+        path.moveTo(bitmap.getWidth() / 2, bitmap.getHeight());
+        path.lineTo(bitmap.getWidth(), 50);
+
+        canvas.drawTextOnPath(text, path, 20, 20, paint);
+
+        return bitmap;
+    }
+
+    /**
+     * dip转pix
+     *
+     * @param context
+     * @param dp
+     * @return
+     */
+    public static int dp2px(Context context, float dp) {
+        final float scale = context.getResources().getDisplayMetrics().density;
+        return (int) (dp * scale + 0.5f);
+    }
+}
+package com.cnlive.core.ocr.ui.util;
+
+import android.content.res.Resources;
+
+public class PxUtil {
+
+    public static int dp2px(float dpValue) {
+        return (int) (0.5f + dpValue * Resources.getSystem().getDisplayMetrics().density);
+    }
+}
-package com.cnlive.core.people_verfication;
-
-
-import com.cnlive.core.libs.base.frame.activity.BaseActivity;
-
-/**
- * 拍摄照片  身份证件采集
- */
-public class TakePictureActivity extends BaseActivity {
-
-    @Override
-    protected int getViewLayoutId() {
-        return R.layout.activity_take_picture;
-    }
-
-    @Override
-    protected void initView() {
-
-    }
-}
+package com.cnlive.core.people_verfication.activity;
+
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.text.TextUtils;
+
+import com.baidu.ocr.sdk.model.IDCardParams;
+import com.cnlive.core.libs.base.frame.activity.BaseActivity;
+import com.cnlive.core.libs.base.util.FileUtils;
+import com.cnlive.core.ocr.ui.camera.CameraActivity;
+import com.cnlive.core.people_verfication.R;
+import com.cnlive.core.people_verfication.databinding.ActivityTakePictureBinding;
+import com.cnlive.core.people_verfication.presenter.TakeIdentityPicturePresenter;
+import com.cnlive.core.people_verfication.view.ICertificatePhohosView;
+import com.cnlive.core.people_verfication.view.TakeIdentityPictureView;
+import com.cnlive.media.picker.utils.PermissionChecker;
+
+import androidx.annotation.NonNull;
+import androidx.databinding.ViewDataBinding;
+
+/**
+ * 拍摄照片  身份证件采集
+ */
+public class TakeIdentityPictureActivity extends BaseActivity<TakeIdentityPictureView, TakeIdentityPicturePresenter> {
+
+    public ActivityTakePictureBinding binding;
+    //上一个被点击过的btn的点击时间
+    private long preViewClickTime = 0;
+    //上一个被点击过的btn的id
+    private int preViewClickId = 0;
+    private static int CAMERA_WRITE_FR_PERMISSION = 1001;
+    private static int CAMERA_WRITE_BA_PERMISSION = 1002;
+
+    @Override
+    protected int getBindLayoutId() {
+        return R.layout.activity_take_picture;
+    }
+
+    @Override
+    protected void initBindingLayoutData(ViewDataBinding baseBinding) {
+        binding = (ActivityTakePictureBinding) baseBinding;
+    }
+
+    @Override
+    protected void initView() {
+        binding.topbar.setTitle("拍摄照片");
+        binding.topbar.setLeft(R.drawable.back);
+        binding.topbar.addLeftImageButton(R.drawable.top_back_black, R.id.fragment_back).setOnClickListener(v -> {
+            finish();
+        });
+        binding.setClick(v -> onClick(v.getId()));
+    }
+
+    private void onClick(int id) {
+        long curClickTime = System.currentTimeMillis();
+        if (preViewClickId > 0 && preViewClickTime > 0) {
+            if (preViewClickId == id && curClickTime - preViewClickTime <= 2000) {
+                return;
+            }
+        }
+        preViewClickTime = curClickTime;
+        preViewClickId = id;
+        if (id == R.id.certificate_front) {
+            if(hasCampermission(CAMERA_WRITE_FR_PERMISSION)){//权限判断
+                getMvpView().takeIdCardPictures(this, ICertificatePhohosView.ID_CARD_SIDE_FRONT);
+            }
+        } else if (id == R.id.certificate_back) {
+            if(hasCampermission(CAMERA_WRITE_BA_PERMISSION)){//权限判断
+                getMvpView().takeIdCardPictures(this, ICertificatePhohosView.ID_CARD_SIDE_BACK);
+            }
+        } else if (id == R.id.take_picture) {
+
+        }
+    }
+
+    private boolean hasCampermission(int typeNum){
+        boolean hasPermission = PermissionChecker.checkPermissions(this
+                , new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}
+                , typeNum, R.string.dialog_imagepicker_permission_camera_nerver_ask_message);
+        return hasPermission;
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        if (requestCode == CAMERA_WRITE_FR_PERMISSION) {
+            if (PermissionChecker.onRequestPermissionsResult(this,requestCode, permissions, grantResults, false, R.string.dialog_imagepicker_permission_sdcard_message)[0]) {
+                getMvpView().takeIdCardPictures(this, ICertificatePhohosView.ID_CARD_SIDE_FRONT);
+            }
+        }else if(requestCode == CAMERA_WRITE_BA_PERMISSION){
+            if (PermissionChecker.onRequestPermissionsResult(this,requestCode, permissions, grantResults, false, R.string.dialog_imagepicker_permission_sdcard_message)[0]) {
+                getMvpView().takeIdCardPictures(this, ICertificatePhohosView.ID_CARD_SIDE_BACK);
+            }
+        }
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (requestCode == ICertificatePhohosView.REQUEST_CODE_CAMERA && resultCode == Activity.RESULT_OK) {
+            if (data != null) {
+                String contentType = data.getStringExtra(CameraActivity.KEY_CONTENT_TYPE);
+                if (!TextUtils.isEmpty(contentType)) {
+                    if (CameraActivity.CONTENT_TYPE_ID_CARD_FRONT.equals(contentType)) {
+                        String frontFilePath = FileUtils.getSaveFile(getApplicationContext(), ICertificatePhohosView.PIC_FRONT).getAbsolutePath();
+                        if (getMvpView() == null) return;
+                        getMvpView().recIDCard(IDCardParams.ID_CARD_SIDE_FRONT, frontFilePath);
+
+                    } else if (CameraActivity.CONTENT_TYPE_ID_CARD_BACK.equals(contentType)) {
+                        String backFilePath = FileUtils.getSaveFile(getApplicationContext(), ICertificatePhohosView.PIC_BACK).getAbsolutePath();
+                        if (getMvpView() == null) return;
+                        getMvpView().recIDCard(IDCardParams.ID_CARD_SIDE_BACK, backFilePath);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+//        if (getPresenter() != null) getPresenter().cancel();
+    }
+}
+package com.cnlive.core.people_verfication.presenter;
+
+import com.cnlive.core.libs.base.frame.presenter.BasePresenter;
+import com.cnlive.core.people_verfication.view.TakeIdentityPictureView;
+
+public class TakeIdentityPicturePresenter extends BasePresenter<TakeIdentityPictureView> {
+
+}
+package com.cnlive.core.people_verfication.view;
+
+import com.hannesdorfmann.mosby3.mvp.MvpView;
+
+/**
+ * Created by cnlive20080010 on 2018/10/9.
+ */
+
+public interface ICertificatePhohosView extends MvpView {
+    int REQUEST_CODE_CAMERA = 102;
+    int ID_CARD_SIDE_FRONT = 1;
+    int ID_CARD_SIDE_BACK = 2;
+    String PIC_FRONT = "pic_front";
+    String PIC_BACK = "pic_back";
+}
+package com.cnlive.core.people_verfication.view;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.hardware.Camera;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.widget.ImageView;
+
+import com.baidu.ocr.sdk.OCR;
+import com.baidu.ocr.sdk.OnResultListener;
+import com.baidu.ocr.sdk.exception.OCRError;
+import com.baidu.ocr.sdk.model.AccessToken;
+import com.baidu.ocr.sdk.model.IDCardParams;
+import com.baidu.ocr.sdk.model.IDCardResult;
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.request.RequestOptions;
+import com.cnlive.core.libs.base.application.AppConfig;
+import com.cnlive.core.libs.base.frame.view.BaseView;
+import com.cnlive.core.libs.base.util.AlertUtil;
+import com.cnlive.core.libs.base.util.FileUtils;
+import com.cnlive.core.libs.base.util.GlideUtil;
+import com.cnlive.core.ocr.RecognizeService;
+import com.cnlive.core.ocr.ui.camera.CameraActivity;
+import com.cnlive.core.ocr.ui.util.ImageUtil;
+import com.cnlive.core.people_verfication.R;
+import com.cnlive.core.people_verfication.activity.TakeIdentityPictureActivity;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import static com.cnlive.core.people_verfication.view.ICertificatePhohosView.PIC_BACK;
+import static com.cnlive.core.people_verfication.view.ICertificatePhohosView.PIC_FRONT;
+
+public class TakeIdentityPictureView extends BaseView {
+
+    public TakeIdentityPictureActivity activity;
+    //上一个被点击过的btn的点击时间
+    private long preViewClickTime = 0;
+    private boolean isFrontEffective = false;
+    private boolean isBackEffective = false;
+    private String idCardNo;
+    private String realName;
+
+    public TakeIdentityPictureView(TakeIdentityPictureActivity activity) {
+        this.activity = activity;
+    }
+
+    private Activity getContext() {
+        return activity == null ? null : activity;
+    }
+
+    public void finish() {
+        activity.finish();
+    }
+
+    /**
+     * 拍摄
+     *
+     * @param idCardSide
+     */
+    public void takeIdCardPictures(Context context, final int idCardSide) {
+        long curClickTime = System.currentTimeMillis();
+        if (preViewClickTime > 0 && curClickTime - preViewClickTime <= 2000 ) {
+            return;
+        }
+        preViewClickTime = curClickTime;
+        OCR.getInstance().initAccessTokenWithAkSk(new OnResultListener<AccessToken>() {
+            @Override
+            public void onResult(AccessToken result) {
+                String token = result.getAccessToken();
+                if (idCardSide == ICertificatePhohosView.ID_CARD_SIDE_FRONT) {
+                    takePhoto(PIC_FRONT, CameraActivity.CONTENT_TYPE_ID_CARD_FRONT);
+                } else if (idCardSide == ICertificatePhohosView.ID_CARD_SIDE_BACK) {
+                    takePhoto(PIC_BACK, CameraActivity.CONTENT_TYPE_ID_CARD_BACK);
+                }
+            }
+
+            @Override
+            public void onError(OCRError error) {
+                error.printStackTrace();
+                new Thread() {
+                    @Override
+                    public void run() {
+                        new Handler(Looper.getMainLooper()).post(new Runnable() {
+                            @Override
+                            public void run() {
+                                AlertUtil.showDeftToast(getContext(), getContext().getString(R.string.init_baidu_faile));
+                            }
+                        });
+                    }
+                }.start();
+            }
+        }, context, AppConfig.getBaiduAppKey(), AppConfig.getBaiduAppSecret());
+    }
+
+    /**
+     * 拍摄身份证
+     *
+     * @param fileName
+     * @param contentType
+     */
+    public void takePhoto(String fileName, String contentType) {
+        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
+        Camera camera = null;
+        int cameraId = 0;
+        for (int i = 0; i < Camera.getNumberOfCameras(); i++) {
+            Camera.getCameraInfo(i, cameraInfo);
+            if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
+                cameraId = i;
+            }
+        }
+        try {
+            camera = Camera.open(cameraId);
+            Intent intent = new Intent(getContext(), CameraActivity.class);
+            intent.putExtra(CameraActivity.KEY_OUTPUT_FILE_PATH,
+                    FileUtils.getSaveFile(getContext().getApplication(), fileName).getAbsolutePath());
+            intent.putExtra(CameraActivity.KEY_CONTENT_TYPE, contentType);
+            getContext().startActivityForResult(intent, ICertificatePhohosView.REQUEST_CODE_CAMERA);
+            camera.release();
+        } catch (Throwable e) {
+            e.printStackTrace();
+            AlertUtil.showDeftToast(getContext(),"没有相机权限，相机开启失败");
+            return;
+        }
+    }
+
+    /**
+     * 展示拍摄的身份证，并获取身份证信息
+     *
+     * @param idCardSide
+     * @param bitmap
+     * @param imageView
+     */
+    public void showIdCard(String idCardSide, Bitmap bitmap, ImageView imageView) {
+        RequestOptions options = new RequestOptions();
+        options.skipMemoryCache(true);
+        options.diskCacheStrategy(DiskCacheStrategy.NONE);
+        GlideUtil.into(imageView, bitmap, options);
+    }
+
+    /**
+     * 身份证人像面信息是否完整
+     *
+     * @param idCardResult
+     * @return
+     */
+    private boolean isEffectiveFront(IDCardResult idCardResult) {
+        return idCardResult.getName() != null && idCardResult.getAddress() != null && idCardResult.getIdNumber() != null && idCardResult.getBirthday() != null && idCardResult.getGender() != null && idCardResult.getEthnic() != null;
+    }
+
+    /**
+     * 身份证国徽面信息是否完整
+     *
+     * @param idCardResult
+     * @return
+     */
+    private boolean isEffectiveBack(IDCardResult idCardResult) {
+        return idCardResult.getSignDate() != null && idCardResult.getExpiryDate() != null && idCardResult.getIssueAuthority() != null;
+    }
+
+    private Bitmap frontBitmap;
+    private Bitmap backBitmap;
+
+    /**
+     * 验证身份证信息
+     *
+     * @param idCardSide
+     * @param filePath
+     */
+    public void recIDCard(final String idCardSide, final String filePath) {
+        RecognizeService.recIDCard(idCardSide, filePath, new OnResultListener<IDCardResult>() {
+            @Override
+            public void onResult(IDCardResult idCardResult) {
+                if (idCardResult != null) {
+                    if (isEffectiveFront(idCardResult) || isEffectiveBack(idCardResult)) {
+                        Bitmap bitmap = ImageUtil.drawTextToRightBottom(getContext(), BitmapFactory.decodeFile(filePath), getContext().getString(R.string.only_for_verified), 20, getContext().getResources().getColor(R.color.grayText), 10, 10);
+
+                        if (idCardSide.equals(IDCardParams.ID_CARD_SIDE_FRONT)) {
+                            isFrontEffective = true;
+                            idCardNo = idCardResult.getIdNumber().toString();
+                            realName = idCardResult.getName().toString();
+                            if (TextUtils.isEmpty(idCardNo) || TextUtils.isEmpty(realName)) {
+//                                activity.binding.submit.setClickable(false);
+                                AlertUtil.showDeftToast(getContext(), "身份证信息读取失败，请重新拍摄");
+                                return;
+                            }
+                            frontBitmap = bitmap;
+                            showIdCard(idCardSide, frontBitmap, activity.binding.certificateFront);
+                            activity.binding.certificateFront.setImageBitmap(bitmap);
+                            if(isBackEffective){
+//                                activity.binding.submit.setClickable(true);
+//                                activity.binding.submit.setTextColor(activity.getResources().getColor(R.color.white));
+//                                activity.binding.submit.setBackground(getContext().getResources().getDrawable(R.drawable.bg_apply_btn));
+                            }
+                        }
+
+                        if (idCardSide.equals(IDCardParams.ID_CARD_SIDE_BACK)) {
+                            backBitmap = bitmap;
+                            isBackEffective = true;
+                            if(TextUtils.isEmpty(idCardResult.getIssueAuthority().toString().trim()) ||
+                                    TextUtils.isEmpty(idCardResult.getSignDate().toString().trim())){
+//                                activity.binding.submit.setClickable(false);
+                                AlertUtil.showDeftToast(getContext(), "身份证信息读取失败，请重新拍摄");
+                                return;
+                            }
+                            try{
+                                Integer.parseInt(idCardResult.getExpiryDate().toString().trim());
+                                if(idCardResult.getExpiryDate() != null && Integer.parseInt(idCardResult.getExpiryDate().toString().trim()) < getCurrentTime()){
+//                                    activity.binding.submit.setClickable(false);
+                                    AlertUtil.showDeftToast(getContext(), "身份证有效期失效");
+                                    return;
+                                }
+                            }catch (Exception e){
+                                e.printStackTrace();
+                            }
+
+
+                            showIdCard(idCardSide, backBitmap, activity.binding.certificateBack);
+                            activity.binding.certificateBack.setImageBitmap(bitmap);
+                            if (!TextUtils.isEmpty(idCardNo) && !TextUtils.isEmpty(realName)) {
+//                                activity.binding.submit.setClickable(true);
+//                                activity.binding.submit.setTextColor(activity.getResources().getColor(R.color.white));
+//                                activity.binding.submit.setBackground(getContext().getResources().getDrawable(R.drawable.bg_apply_btn));
+                            }
+                        }
+                    }else {
+//                        activity.binding.submit.setClickable(false);
+                        AlertUtil.showDeftToast(getContext(), "身份证信息读取失败，请重新拍摄");
+                    }
+                }
+            }
+
+            @Override
+            public void onError(OCRError ocrError) {
+                if (ocrError.getErrorCode() == 283504) {
+                    AlertUtil.showDeftToast(getContext(), "网络请求失败,请稍后再试");
+                } else {
+                    AlertUtil.showDeftToast(getContext(), "识别失败，请重拍");
+                }
+            }
+        });
+
+    }
+
+    private Integer getCurrentTime() {
+        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyyMMdd");
+        String date = sDateFormat.format(new Date());
+        return Integer.parseInt(date);
+    }
+
+    public File compressImage(Bitmap bitmap, String filename) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
+        int options = 100;
+        while (baos.toByteArray().length / 1024 > 500) {  //循环判断如果压缩后图片是否大于500kb,大于继续压缩
+            baos.reset();//重置baos即清空baos
+            options -= 10;//每次都减少10
+            bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
+            long length = baos.toByteArray().length;
+        }
+        File file = new File(Environment.getExternalStorageDirectory() + "/aegis/file");
+        if (!file.exists()) {
+            file.mkdirs();
+        }
+        file = new File(Environment.getExternalStorageDirectory() + "/aegis/file/", filename + ".png");
+        try {
+            FileOutputStream fos = new FileOutputStream(file);
+            try {
+                fos.write(baos.toByteArray());
+                fos.flush();
+                fos.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+//        recycleBitmap(bitmap);
+        return file;
+    }
+}
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="#000000" />
+    <corners android:radius="12dp" />
+</shape>  
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- 按压时 -->
+    <item android:drawable="@drawable/bd_ocr_take_photo_highlight" android:state_pressed="true" />
+    <!-- 被选中时 -->
+    <item android:drawable="@drawable/bd_ocr_take_photo_normal" android:state_selected="true" />
+    <!-- 被激活时 -->
+    <item android:drawable="@drawable/bd_ocr_take_photo_normal" android:state_activated="true" />
+    <!-- 默认时 -->
+    <item android:drawable="@drawable/bd_ocr_take_photo_normal" />
+</selector>
 \ No newline at end of file