barcodes);
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/callback/act/ActResultRequest.java
================================================
package com.maning.mlkitscanner.scan.callback.act;
import android.app.Activity;
import android.app.FragmentManager;
import android.content.Intent;
/**
*
* author : maning
* e-mail : xxx@xx
* time : 2018/06/04
* desc :
* version: 1.0
*
*/
public class ActResultRequest {
private OnActResultEventDispatcherFragment fragment;
public ActResultRequest(Activity activity) {
fragment = getEventDispatchFragment(activity);
}
private OnActResultEventDispatcherFragment getEventDispatchFragment(Activity activity) {
final FragmentManager fragmentManager = activity.getFragmentManager();
OnActResultEventDispatcherFragment fragment = findEventDispatchFragment(fragmentManager);
if (fragment == null) {
fragment = new OnActResultEventDispatcherFragment();
fragmentManager
.beginTransaction()
.add(fragment, OnActResultEventDispatcherFragment.TAG)
.commitAllowingStateLoss();
fragmentManager.executePendingTransactions();
}
return fragment;
}
private OnActResultEventDispatcherFragment findEventDispatchFragment(FragmentManager manager) {
return (OnActResultEventDispatcherFragment) manager.findFragmentByTag(OnActResultEventDispatcherFragment.TAG);
}
public void startForResult(Intent intent, MNScanCallback callback) {
fragment.startForResult(intent, callback);
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/callback/act/MNScanCallback.java
================================================
package com.maning.mlkitscanner.scan.callback.act;
import android.content.Intent;
/**
*
* author : maning
* e-mail : xxx@xx
* time : 2018/06/04
* desc :
* version: 1.0
*
*/
public interface MNScanCallback {
void onActivityResult(int resultCode, Intent data);
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/callback/act/OnActResultEventDispatcherFragment.java
================================================
package com.maning.mlkitscanner.scan.callback.act;
import android.app.Fragment;
import android.content.Intent;
import android.os.Bundle;
import android.util.SparseArray;
/**
*
* author : maning
* e-mail : xxx@xx
* time : 2018/06/04
* desc :
* version: 1.0
*
*/
public class OnActResultEventDispatcherFragment extends Fragment {
public static final String TAG = "on_act_result_event_dispatcher";
private SparseArray mCallbacks = new SparseArray<>();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
public void startForResult(Intent intent, MNScanCallback callback) {
mCallbacks.put(callback.hashCode(), callback);
startActivityForResult(intent, callback.hashCode());
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
MNScanCallback callback = mCallbacks.get(requestCode);
mCallbacks.remove(requestCode);
if (callback != null) {
callback.onActivityResult(resultCode, data);
}
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/camera/CameraManager.java
================================================
package com.maning.mlkitscanner.scan.camera;
import android.content.Context;
import android.graphics.Bitmap;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import androidx.camera.core.Camera;
import androidx.camera.core.CameraSelector;
import androidx.camera.core.FocusMeteringAction;
import androidx.camera.core.ImageAnalysis;
import androidx.camera.core.MeteringPoint;
import androidx.camera.core.Preview;
import androidx.camera.core.ZoomState;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.camera.view.PreviewView;
import androidx.core.content.ContextCompat;
import androidx.lifecycle.LifecycleOwner;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.mlkit.vision.barcode.common.Barcode;
import com.maning.mlkitscanner.scan.analyser.BarcodeAnalyser;
import com.maning.mlkitscanner.scan.callback.OnCameraAnalyserCallback;
import com.maning.mlkitscanner.scan.model.MNScanConfig;
import com.maning.mlkitscanner.scan.utils.BeepManager;
import java.util.List;
import java.util.concurrent.Executors;
/**
* @author : maning
* @date : 8/19/21
* @desc :
*/
public class CameraManager {
private static final int HOVER_TAP_TIMEOUT = 150;
private static final int HOVER_TAP_SLOP = 20;
private ListenableFuture cameraProviderFuture;
private LifecycleOwner mLifecycleOwner;
private Camera mCamera;
private long mLastHoveTapTime;
private boolean isClickTap;
private float mDownX;
private float mDownY;
private PreviewView mPreviewView;
private Context mContext;
private BarcodeAnalyser barcodeAnalyser;
private OnCameraAnalyserCallback onCameraAnalyserCallback;
private MNScanConfig scanConfig;
private BeepManager beepManager;
public static CameraManager getInstance(Context mContext, PreviewView mPreviewView) {
return new CameraManager(mContext, mPreviewView);
}
public CameraManager(Context mContext, PreviewView mPreviewView) {
this.mContext = mContext;
this.mPreviewView = mPreviewView;
initDatas();
}
public BarcodeAnalyser getBarcodeAnalyser() {
return barcodeAnalyser;
}
public void setOnCameraAnalyserCallback(OnCameraAnalyserCallback callback) {
this.onCameraAnalyserCallback = callback;
}
public void setScanConfig(MNScanConfig config) {
scanConfig = config;
beepManager.setPlayBeep(scanConfig.isShowBeep());
beepManager.setVibrate(scanConfig.isShowVibrate());
}
public void setAnalyze(boolean analyze) {
barcodeAnalyser.setAnalyze(analyze);
}
private void initDatas() {
mLifecycleOwner = (LifecycleOwner) mContext;
beepManager = new BeepManager(mContext);
initBarcodeAnalyser();
initScaleGesture();
}
public void startCamera() {
cameraProviderFuture = ProcessCameraProvider.getInstance(mContext);
cameraProviderFuture.addListener(new Runnable() {
@Override
public void run() {
try {
ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
Preview preview = new Preview.Builder().build();
//绑定预览
preview.setSurfaceProvider(mPreviewView.getSurfaceProvider());
//使用后置相机
CameraSelector cameraSelector = new CameraSelector.Builder()
.requireLensFacing(CameraSelector.LENS_FACING_BACK)
.build();
//配置图片扫描
ImageAnalysis imageAnalysis = new ImageAnalysis.Builder()
.setTargetResolution(CameraSizeUtils.getSize(mContext))
.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
.build();
imageAnalysis.setAnalyzer(Executors.newSingleThreadExecutor(), barcodeAnalyser);
if (mCamera != null) {
cameraProviderFuture.get().unbindAll();
}
//将相机绑定到当前控件的生命周期
mCamera = cameraProvider.bindToLifecycle(mLifecycleOwner, cameraSelector, imageAnalysis, preview);
} catch (Exception e) {
}
}
}, ContextCompat.getMainExecutor(mContext));
}
private void initBarcodeAnalyser() {
barcodeAnalyser = new BarcodeAnalyser();
barcodeAnalyser.setPreviewView(mPreviewView);
barcodeAnalyser.setAnalyze(true);
barcodeAnalyser.setOnCameraAnalyserCallback(new OnCameraAnalyserCallback() {
@Override
public void onSuccess(Bitmap bitmap, List barcodes) {
beepManager.playBeepSoundAndVibrate();
if (onCameraAnalyserCallback != null) {
onCameraAnalyserCallback.onSuccess(bitmap, barcodes);
}
}
});
}
private void initScaleGesture() {
ScaleGestureDetector scaleGestureDetector = new ScaleGestureDetector(mContext, mOnScaleGestureListener);
mPreviewView.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View view, MotionEvent event) {
handlePreviewViewClickTap(event);
if (scanConfig != null && scanConfig.isSupportZoom()) {
return scaleGestureDetector.onTouchEvent(event);
}
return false;
}
});
}
private ScaleGestureDetector.OnScaleGestureListener mOnScaleGestureListener = new ScaleGestureDetector.SimpleOnScaleGestureListener() {
@Override
public boolean onScale(ScaleGestureDetector detector) {
float scale = detector.getScaleFactor();
if (mCamera != null) {
float ratio = mCamera.getCameraInfo().getZoomState().getValue().getZoomRatio();
zoomTo(ratio * scale);
}
return true;
}
};
private void handlePreviewViewClickTap(MotionEvent event) {
if (event.getPointerCount() == 1) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
isClickTap = true;
mDownX = event.getX();
mDownY = event.getY();
mLastHoveTapTime = System.currentTimeMillis();
break;
case MotionEvent.ACTION_MOVE:
isClickTap = distance(mDownX, mDownY, event.getX(), event.getY()) < HOVER_TAP_SLOP;
break;
case MotionEvent.ACTION_UP:
if (isClickTap && mLastHoveTapTime + HOVER_TAP_TIMEOUT > System.currentTimeMillis()) {
startFocusAndMetering(event.getX(), event.getY());
}
break;
}
}
}
private float distance(float aX, float aY, float bX, float bY) {
float xDiff = aX - bX;
float yDiff = aY - bY;
return (float) Math.sqrt(xDiff * xDiff + yDiff * yDiff);
}
public void zoomTo(float ratio) {
if (mCamera != null) {
ZoomState zoomState = mCamera.getCameraInfo().getZoomState().getValue();
float maxRatio = zoomState.getMaxZoomRatio();
float minRatio = zoomState.getMinZoomRatio();
float zoom = Math.max(Math.min(ratio, maxRatio), minRatio);
mCamera.getCameraControl().setZoomRatio(zoom);
}
}
private void startFocusAndMetering(float x, float y) {
if (mCamera != null) {
MeteringPoint point = mPreviewView.getMeteringPointFactory().createPoint(x, y);
mCamera.getCameraControl().startFocusAndMetering(new FocusMeteringAction.Builder(point).build());
}
}
public void openLight() {
if (mCamera != null) {
mCamera.getCameraControl().enableTorch(true);
}
}
public void closeLight() {
if (mCamera != null) {
mCamera.getCameraControl().enableTorch(false);
}
}
public void stopCamera() {
try {
if (cameraProviderFuture != null) {
cameraProviderFuture.get().unbindAll();
}
} catch (Exception e) {
}
}
public void release() {
try {
mPreviewView = null;
mLifecycleOwner = null;
stopCamera();
} catch (Exception e) {
}
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/camera/CameraSizeUtils.java
================================================
package com.maning.mlkitscanner.scan.camera;
import android.content.Context;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.Size;
/**
* @author : maning
* @date : 8/19/21
* @desc :
*/
public class CameraSizeUtils {
public static Size getSize(Context context) {
Size mTargetSize;
DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
int width = displayMetrics.widthPixels;
int height = displayMetrics.heightPixels;
Log.i("======", String.format("displayMetrics:%d x %d", width, height));
//因为为了保持流畅性和性能，限制在1080p，在此前提下尽可能的找到屏幕接近的分辨率
if (width < height) {
int size = Math.min(width, 1080);
float ratio = width / (float) height;
if (ratio > 0.7) {//一般应用于平板
mTargetSize = new Size(size, (int) (size / 3.0f * 4.0f));
} else {
mTargetSize = new Size(size, (int) (size / 9.0f * 16.0f));
}
} else {
int size = Math.min(height, 1080);
float ratio = height / (float) width;
if (ratio > 0.7) {//一般应用于平板
mTargetSize = new Size((int) (size / 3.0f * 4.0f), size);
} else {
mTargetSize = new Size((int) (size / 9.0f * 16.0), size);
}
}
Log.i("======", "mTargetSize:" + mTargetSize.getWidth() + "," + mTargetSize.getHeight());
return mTargetSize;
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/model/MNScanConfig.java
================================================
package com.maning.mlkitscanner.scan.model;
import com.maning.mlkitscanner.R;
import com.maning.mlkitscanner.scan.callback.MNCustomViewBindCallback;
import java.io.Serializable;
/**
* Created by maning on 2017/12/7.
* 启动Activity的一些配置参数
*/
public class MNScanConfig implements Serializable {
private static final long serialVersionUID = -5260676142223049891L;
public static MNCustomViewBindCallback mCustomViewBindCallback;
//枚举类型：扫描线样式
public enum LaserStyle {
Line,
Grid,
}
//是否显示相册
private boolean showPhotoAlbum;
//扫描声音
private boolean showBeep;
//扫描震动
private boolean showVibrate;
//扫描框和扫描线的颜色
private String scanColor;
//扫描线的样式
private LaserStyle laserStyle;
//扫描提示文案
private String scanHintText;
//扫描提示文案颜色
private String scanHintTextColor;
//扫描提示文案字体大小
private int scanHintTextSize;
//开启Activity动画
private int activityOpenAnime;
//关闭Activity动画
private int activityExitAnime;
//是否支持手势缩放，默认支持
private boolean isSupportZoom = true;
//自定义View
private int customShadeViewLayoutID;
//扫描背景色
private String bgColor;
//网格扫描线的列数
private int gridScanLineColumn;
//网格扫描线的高度
private int gridScanLineHeight;
//显示闪光灯
private boolean showLightController = true;
//是否需要全屏扫描，默认全屏扫描
private boolean isFullScreenScan = true;
//扫描二维码中心点宽高
private int resultPointWithdHeight = 0;
//扫描二维码中心点显示圆角
private int resultPointCorners = 0;
//扫描二维码中心点显示描边
private int resultPointStrokeWidth = 0;
//扫描二维码中心点显示描边颜色
private String resultPointStrokeColor;
//扫描二维码中心点显示颜色
private String resultPointColor;
//状态栏颜色
private String statusBarColor = "#00000000";
//状态栏是否显示黑色字体
private boolean statusBarDarkMode = false;
//扫描框宽度大小比例，非全屏模式下生效，默认0.7，范围0.5-0.9
private float scanFrameSizeScale = 0.7f;
private MNScanConfig() {
}
private MNScanConfig(Builder builder) {
showPhotoAlbum = builder.showPhotoAlbum;
showBeep = builder.showBeep;
showVibrate = builder.showVibrate;
scanColor = builder.scanColor;
laserStyle = builder.laserStyle;
scanHintText = builder.scanHintText;
activityOpenAnime = builder.activityOpenAnime;
activityExitAnime = builder.activityExitAnime;
customShadeViewLayoutID = builder.customShadeViewLayoutID;
bgColor = builder.bgColor;
gridScanLineColumn = builder.gridScanLineColumn;
gridScanLineHeight = builder.gridScanLineHeight;
showLightController = builder.showLightController;
scanHintTextColor = builder.scanHintTextColor;
scanHintTextSize = builder.scanHintTextSize;
isFullScreenScan = builder.isFullScreenScan;
isSupportZoom = builder.isSupportZoom;
resultPointWithdHeight = builder.resultPointWithdHeight;
resultPointCorners = builder.resultPointCorners;
resultPointStrokeWidth = builder.resultPointStrokeWidth;
resultPointStrokeColor = builder.resultPointStrokeColor;
resultPointColor = builder.resultPointColor;
statusBarColor = builder.statusBarColor;
statusBarDarkMode = builder.statusBarDarkMode;
scanFrameSizeScale = builder.scanFrameSizeScale;
}
public String getStatusBarColor() {
return statusBarColor;
}
public boolean isStatusBarDarkMode() {
return statusBarDarkMode;
}
public int getResultPointWithdHeight() {
return resultPointWithdHeight;
}
public int getResultPointCorners() {
return resultPointCorners;
}
public int getResultPointStrokeWidth() {
return resultPointStrokeWidth;
}
public String getResultPointStrokeColor() {
return resultPointStrokeColor;
}
public String getResultPointColor() {
return resultPointColor;
}
public boolean isShowPhotoAlbum() {
return showPhotoAlbum;
}
public boolean isShowBeep() {
return showBeep;
}
public boolean isShowVibrate() {
return showVibrate;
}
public String getScanColor() {
return scanColor;
}
public LaserStyle getLaserStyle() {
return laserStyle;
}
public String getScanHintText() {
return scanHintText;
}
public String getScanHintTextColor() {
return scanHintTextColor;
}
public int getScanHintTextSize() {
return scanHintTextSize;
}
public int getActivityOpenAnime() {
return activityOpenAnime;
}
public int getActivityExitAnime() {
return activityExitAnime;
}
public int getCustomShadeViewLayoutID() {
return customShadeViewLayoutID;
}
public String getBgColor() {
return bgColor;
}
public int getGridScanLineColumn() {
return gridScanLineColumn;
}
public int getGridScanLineHeight() {
return gridScanLineHeight;
}
public boolean isShowLightController() {
return showLightController;
}
public boolean isFullScreenScan() {
return isFullScreenScan;
}
public boolean isSupportZoom() {
return isSupportZoom;
}
public float getScanFrameSizeScale() {
if (scanFrameSizeScale > 0.9) {
scanFrameSizeScale = 0.9f;
}
if (scanFrameSizeScale < 0.5) {
scanFrameSizeScale = 0.5f;
}
return scanFrameSizeScale;
}
public static class Builder {
private boolean showPhotoAlbum = true;
private boolean showBeep = true;
private boolean showVibrate = true;
//扫描颜色
private String scanColor;
private String bgColor;
private LaserStyle laserStyle = LaserStyle.Line;
private int activityOpenAnime = R.anim.mn_scan_activity_bottom_in;
private int activityExitAnime = R.anim.mn_scan_activity_bottom_out;
private int customShadeViewLayoutID;
//网格扫描线的列数
private int gridScanLineColumn;
//网格扫描线的高度
private int gridScanLineHeight;
//闪光灯
private boolean showLightController = true;
//扫描提示文案
private String scanHintText = "扫二维码/条形码";
//扫描提示文案颜色
private String scanHintTextColor;
//扫描提示文案字体大小
private int scanHintTextSize;
//是否需要全屏扫描，默认值扫描扫描框中的二维码
private boolean isFullScreenScan = true;
//是否支持手势缩放，默认支持
private boolean isSupportZoom = true;
//扫描二维码中心点显示半径
private int resultPointWithdHeight = 0;
//扫描二维码中心点显示圆角
private int resultPointCorners = 0;
//扫描二维码中心点显示描边
private int resultPointStrokeWidth = 0;
//扫描二维码中心点显示描边颜色
private String resultPointStrokeColor;
//扫描二维码中心点显示颜色
private String resultPointColor;
//状态栏颜色
private String statusBarColor = "#00000000";
//状态栏是否显示黑色字体
private boolean statusBarDarkMode = false;
//扫描框宽度大小比例，非全屏模式下生效，默认0.7，范围0.5-0.9
private float scanFrameSizeScale = 0.7f;
public MNScanConfig builder() {
return new MNScanConfig(this);
}
public Builder setStatusBarConfigs(String statusBarColor,
boolean statusBarDarkMode) {
this.statusBarColor = statusBarColor;
this.statusBarDarkMode = statusBarDarkMode;
return this;
}
/**
* 设置扫描点大小圆角等（单位dp）
*
* @param resultPointWithdHeight
* @param resultPointCorners
* @param resultPointStrokeWidth
* @param resultPointStrokeColor
* @param resultPointColor
* @return
*/
public Builder setResultPointConfigs(int resultPointWithdHeight,
int resultPointCorners,
int resultPointStrokeWidth,
String resultPointStrokeColor,
String resultPointColor) {
this.resultPointWithdHeight = resultPointWithdHeight;
this.resultPointCorners = resultPointCorners;
this.resultPointStrokeWidth = resultPointStrokeWidth;
this.resultPointStrokeColor = resultPointStrokeColor;
this.resultPointColor = resultPointColor;
return this;
}
public Builder setLaserStyle(LaserStyle laserStyle) {
this.laserStyle = laserStyle;
return this;
}
public Builder isShowPhotoAlbum(boolean showPhotoAlbum) {
this.showPhotoAlbum = showPhotoAlbum;
return this;
}
public Builder isShowBeep(boolean showBeep) {
this.showBeep = showBeep;
return this;
}
public Builder isShowVibrate(boolean showVibrate) {
this.showVibrate = showVibrate;
return this;
}
public Builder setScanColor(String scanColor) {
this.scanColor = scanColor;
return this;
}
public Builder setScanHintText(String scanHintText) {
this.scanHintText = scanHintText;
return this;
}
public Builder setActivityOpenAnime(int activityOpenAnime) {
this.activityOpenAnime = activityOpenAnime;
return this;
}
public Builder setActivityExitAnime(int activityExitAnime) {
this.activityExitAnime = activityExitAnime;
return this;
}
public Builder setCustomShadeViewLayoutID(int customShadeViewLayoutID, MNCustomViewBindCallback mnCustomViewBindCallback) {
this.customShadeViewLayoutID = customShadeViewLayoutID;
mCustomViewBindCallback = mnCustomViewBindCallback;
return this;
}
public Builder setBgColor(String bgColor) {
this.bgColor = bgColor;
return this;
}
public Builder setGridScanLineColumn(int gridScanLineColumn) {
this.gridScanLineColumn = gridScanLineColumn;
return this;
}
public Builder setGridScanLineHeight(int gridScanLineHeight) {
this.gridScanLineHeight = gridScanLineHeight;
return this;
}
public Builder isShowLightController(boolean showLightController) {
this.showLightController = showLightController;
return this;
}
public Builder setScanHintTextColor(String scanHintTextColor) {
this.scanHintTextColor = scanHintTextColor;
return this;
}
public Builder setScanHintTextSize(int scanHintTextSize) {
this.scanHintTextSize = scanHintTextSize;
return this;
}
public Builder setFullScreenScan(boolean fullScreenScan) {
isFullScreenScan = fullScreenScan;
return this;
}
public Builder setSupportZoom(boolean supportZoom) {
isSupportZoom = supportZoom;
return this;
}
public Builder setScanFrameSizeScale(float widthScale) {
scanFrameSizeScale = widthScale;
return this;
}
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/ui/ScanPreviewActivity.java
================================================
package com.maning.mlkitscanner.scan.ui;
import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.RelativeLayout;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.camera.view.PreviewView;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.mlkit.vision.barcode.common.Barcode;
import com.google.mlkit.vision.common.InputImage;
import com.maning.mlkitscanner.R;
import com.maning.mlkitscanner.scan.MNScanManager;
import com.maning.mlkitscanner.scan.callback.OnCameraAnalyserCallback;
import com.maning.mlkitscanner.scan.camera.CameraManager;
import com.maning.mlkitscanner.scan.model.MNScanConfig;
import com.maning.mlkitscanner.scan.utils.BeepManager;
import com.maning.mlkitscanner.scan.utils.ImageUtils;
import com.maning.mlkitscanner.scan.utils.StatusBarUtil;
import com.maning.mlkitscanner.scan.view.ScanActionMenuView;
import com.maning.mlkitscanner.scan.view.ScanResultPointView;
import com.maning.mlkitscanner.scan.view.ViewfinderView;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
public class ScanPreviewActivity extends AppCompatActivity {
//用来保存当前Activity
private static WeakReference sActivityRef;
private static final int REQUEST_CODE_PICK_IMAGE = 10010;
private static final int REQUEST_CODE_PERMISSION_CAMERA = 10011;
private static final int REQUEST_CODE_PERMISSION_STORAGE = 10012;
private Context mContext;
//闪光灯是否打开
private boolean is_light_on = false;
private MNScanConfig mScanConfig;
private CameraManager cameraManager;
private View fakeStatusBar;
private PreviewView mPreviewView;
private ViewfinderView viewfinderView;
private ScanResultPointView result_point_view;
private ScanActionMenuView action_menu_view;
private RelativeLayout rl_act_root;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
setContentView(R.layout.mn_scan_activity_scan_preview);
mContext = this;
sActivityRef = new WeakReference<>(this);
initConfig();
initViews();
initCamera();
initStatusBar();
initPermission();
}
private void initStatusBar() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
StatusBarUtil.setTransparentForWindow(this);
int statusBarHeight = StatusBarUtil.getStatusBarHeight(mContext);
ViewGroup.LayoutParams fakeStatusBarLayoutParams = fakeStatusBar.getLayoutParams();
fakeStatusBarLayoutParams.height = statusBarHeight;
fakeStatusBar.setLayoutParams(fakeStatusBarLayoutParams);
//状态栏文字颜色
if (mScanConfig.isStatusBarDarkMode()) {
StatusBarUtil.setDarkMode(this);
}
//状态栏颜色
String statusBarColor = mScanConfig.getStatusBarColor();
fakeStatusBar.setBackgroundColor(Color.parseColor(statusBarColor));
} else {
ViewGroup.LayoutParams fakeStatusBarLayoutParams = fakeStatusBar.getLayoutParams();
fakeStatusBarLayoutParams.height = 0;
fakeStatusBar.setLayoutParams(fakeStatusBarLayoutParams);
}
}
private void initPermission() {
//检查相机权限
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
//没有相机权限
requestPermissions(new String[]{Manifest.permission.CAMERA}, REQUEST_CODE_PERMISSION_CAMERA);
} else {
startCamera();
}
} else {
startCamera();
}
}
private void initCamera() {
cameraManager = CameraManager.getInstance(sActivityRef.get(), mPreviewView);
cameraManager.setScanConfig(mScanConfig);
cameraManager.setOnCameraAnalyserCallback(new OnCameraAnalyserCallback() {
@Override
public void onSuccess(Bitmap bitmap, List barcodes) {
result_point_view.setDatas(barcodes, bitmap);
result_point_view.setVisibility(View.VISIBLE);
if (barcodes.size() == 1) {
finishSuccess(barcodes.get(0).getDisplayValue());
}
}
});
}
private void startCamera() {
cameraManager.startCamera();
}
private void initConfig() {
mScanConfig = (MNScanConfig) getIntent().getSerializableExtra(MNScanManager.INTENT_KEY_CONFIG_MODEL);
if (mScanConfig == null) {
mScanConfig = new MNScanConfig.Builder().builder();
}
}
private void initViews() {
rl_act_root = (RelativeLayout) findViewById(R.id.rl_act_root);
mPreviewView = (PreviewView) findViewById(R.id.previewView);
mPreviewView.setScaleType(PreviewView.ScaleType.FILL_CENTER);
fakeStatusBar = (View) findViewById(R.id.fakeStatusBar);
viewfinderView = (ViewfinderView) findViewById(R.id.viewfinderView);
action_menu_view = (ScanActionMenuView) findViewById(R.id.action_menu_view);
result_point_view = (ScanResultPointView) findViewById(R.id.result_point_view);
action_menu_view.setOnScanActionMenuListener(new ScanActionMenuView.OnScanActionMenuListener() {
@Override
public void onClose() {
finishCancle();
}
@Override
public void onLight() {
if (is_light_on) {
closeLight();
} else {
openLight();
}
}
@Override
public void onPhoto() {
getImageFromAlbum();
}
});
result_point_view.setOnResultPointClickListener(new ScanResultPointView.OnResultPointClickListener() {
@Override
public void onPointClick(String result) {
finishSuccess(result);
}
@Override
public void onCancle() {
cameraManager.setAnalyze(true);
result_point_view.removeAllPoints();
result_point_view.setVisibility(View.GONE);
}
});
viewfinderView.setScanConfig(mScanConfig);
result_point_view.setScanConfig(mScanConfig);
action_menu_view.setScanConfig(mScanConfig, MNScanConfig.mCustomViewBindCallback);
}
private void openLight() {
if (!is_light_on) {
is_light_on = true;
action_menu_view.openLight();
cameraManager.openLight();
}
}
private void closeLight() {
if (is_light_on) {
is_light_on = false;
action_menu_view.closeLight();
cameraManager.closeLight();
}
}
/**
* 获取相册中的图片
*/
public void getImageFromAlbum() {
if (checkStoragePermission()) {
Intent intent = new Intent();
intent.setAction(Intent.ACTION_PICK);
intent.setType("image/*");
startActivityForResult(intent, REQUEST_CODE_PICK_IMAGE);
}
}
private boolean checkStoragePermission() {
//判断权限
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE}, REQUEST_CODE_PERMISSION_STORAGE);
return false;
}
}
return true;
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
switch (requestCode) {
case REQUEST_CODE_PERMISSION_CAMERA:
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// Permission Granted 授予权限
//用户同意了权限申请
startCamera();
} else {
// Permission Denied 权限被拒绝
Toast.makeText(mContext, "初始化相机失败,相机权限被拒绝", Toast.LENGTH_SHORT).show();
finishFailed("初始化相机失败,相机权限被拒绝");
}
break;
case REQUEST_CODE_PERMISSION_STORAGE:
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
//用户同意使用write
getImageFromAlbum();
} else {
//缺少权限
Toast.makeText(mContext, "打开相册失败,读写权限被拒绝", Toast.LENGTH_SHORT).show();
}
default:
break;
}
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
//去相册选择图片
if (requestCode == REQUEST_CODE_PICK_IMAGE && resultCode == RESULT_OK) {
if (data == null) {
return;
}
Bitmap decodeAbleBitmap = ImageUtils.getBitmap(mContext, data.getData());
if (decodeAbleBitmap == null) {
Log.e("======", "decodeAbleBitmap == null");
return;
}
cameraManager.setAnalyze(false);
new Thread(new Runnable() {
@Override
public void run() {
//分析这个图片
InputImage inputImage = InputImage.fromBitmap(decodeAbleBitmap, 0);
cameraManager.getBarcodeAnalyser().getBarcodeScanner().process(inputImage)
.addOnSuccessListener(new OnSuccessListener>() {
@Override
public void onSuccess(@NonNull List barcodes) {
runOnUiThread(new Runnable() {
@Override
public void run() {
Log.e("======", "barcodes.size():" + barcodes.size());
if (barcodes.size() == 0) {
cameraManager.setAnalyze(true);
Toast.makeText(mContext, "未找到二维码或者条形码", Toast.LENGTH_SHORT).show();
return;
}
ArrayList results = new ArrayList<>();
for (Barcode barcode : barcodes) {
String value = barcode.getDisplayValue();
Log.e("======", "value:" + value);
results.add(value);
}
finishSuccess(results);
}
});
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Log.e("======", "onFailure---:" + e.toString());
}
});
}
}).start();
}
}
@Override
public void onBackPressed() {
if (result_point_view.getVisibility() == View.VISIBLE) {
cameraManager.setAnalyze(true);
result_point_view.removeAllPoints();
result_point_view.setVisibility(View.GONE);
return;
}
//取消扫码
finishCancle();
}
@Override
protected void onDestroy() {
cameraManager.release();
super.onDestroy();
}
private void finishCancle() {
setResult(MNScanManager.RESULT_CANCLE, new Intent());
finishFinal();
}
private void finishFailed(String errorMsg) {
Intent intent = new Intent();
intent.putExtra(MNScanManager.INTENT_KEY_RESULT_ERROR, errorMsg);
setResult(MNScanManager.RESULT_FAIL, intent);
finishFinal();
}
private void finishSuccess(String result) {
ArrayList results = new ArrayList<>();
results.add(result);
finishSuccess(results);
}
private void finishSuccess(ArrayList results) {
Intent intent = new Intent();
intent.putStringArrayListExtra(MNScanManager.INTENT_KEY_RESULT_SUCCESS, results);
setResult(MNScanManager.RESULT_SUCCESS, intent);
finishFinal();
}
private void finishFinal() {
closeLight();
MNScanConfig.mCustomViewBindCallback = null;
sActivityRef = null;
viewfinderView.destroyView();
cameraManager.release();
rl_act_root.removeView(viewfinderView);
rl_act_root.removeView(mPreviewView);
rl_act_root.removeView(action_menu_view);
finish();
overridePendingTransition(0, mScanConfig.getActivityExitAnime() == 0 ? R.anim.mn_scan_activity_bottom_out : mScanConfig.getActivityExitAnime());
}
//---------对外提供方法----------
/**
* 关闭当前Activity
*/
public static void closeScanPage() {
if (sActivityRef != null && sActivityRef.get() != null) {
sActivityRef.get().finishCancle();
}
}
/**
* 打开相册扫描图片
*/
public static void openAlbumPage() {
if (sActivityRef != null && sActivityRef.get() != null) {
sActivityRef.get().getImageFromAlbum();
}
}
/**
* 打开手电筒
*/
public static void openScanLight() {
if (sActivityRef != null && sActivityRef.get() != null) {
sActivityRef.get().openLight();
}
}
/**
* 关闭手电筒
*/
public static void closeScanLight() {
if (sActivityRef != null && sActivityRef.get() != null) {
sActivityRef.get().closeLight();
}
}
/**
* 是否开启手电筒
*/
public static boolean isLightOn() {
if (sActivityRef != null && sActivityRef.get() != null) {
return sActivityRef.get().is_light_on;
}
return false;
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/utils/AmbientLightManager.java
================================================
/*
* Copyright (C) Jenly, MLKit Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.maning.mlkitscanner.scan.utils;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
/**
* @author Jenly
*/
public class AmbientLightManager implements SensorEventListener {
private static final int INTERVAL_TIME = 200;
protected static final float DARK_LUX = 45.0f;
protected static final float BRIGHT_LUX = 100.0f;
/**
* 光线太暗时，默认：照度45 lux
*/
private float darkLightLux = DARK_LUX;
/**
* 光线足够亮时，默认：照度100 lux
*/
private float brightLightLux = BRIGHT_LUX;
private SensorManager sensorManager;
private Sensor lightSensor;
private long lastTime;
private boolean isLightSensorEnabled;
private OnLightSensorEventListener mOnLightSensorEventListener;
public AmbientLightManager(Context context) {
sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
isLightSensorEnabled = true;
}
public void register() {
if (sensorManager != null && lightSensor != null) {
sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
}
}
public void unregister() {
if (sensorManager != null && lightSensor != null) {
sensorManager.unregisterListener(this);
}
}
@Override
public void onSensorChanged(SensorEvent sensorEvent) {
if(isLightSensorEnabled){
long currentTime = System.currentTimeMillis();
if(currentTime - lastTime < INTERVAL_TIME){//降低频率
return;
}
lastTime = currentTime;
if (mOnLightSensorEventListener != null) {
float lightLux = sensorEvent.values[0];
mOnLightSensorEventListener.onSensorChanged(lightLux);
if (lightLux <= darkLightLux) {
mOnLightSensorEventListener.onSensorChanged(true,lightLux);
} else if (lightLux >= brightLightLux) {
mOnLightSensorEventListener.onSensorChanged(false,lightLux);
}
}
}
}
/**
* 设置光线足够暗的阈值（单位：lux）
* @param lightLux
*/
public void setDarkLightLux(float lightLux){
this.darkLightLux = lightLux;
}
/**
* 设置光线足够明亮的阈值（单位：lux）
* @param lightLux
*/
public void setBrightLightLux(float lightLux){
this.brightLightLux = lightLux;
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
// do nothing
}
public boolean isLightSensorEnabled() {
return isLightSensorEnabled;
}
/**
* 设置是否启用光线亮度传感器
* @param lightSensorEnabled
*/
public void setLightSensorEnabled(boolean lightSensorEnabled) {
isLightSensorEnabled = lightSensorEnabled;
}
/**
* 设置光线亮度传感器监听器，只有在 {@link #isLightSensorEnabled} 为{@code true} 才有效
* @param listener
*/
public void setOnLightSensorEventListener(OnLightSensorEventListener listener){
mOnLightSensorEventListener = listener;
}
public interface OnLightSensorEventListener{
/**
*
* @param lightLux 当前检测到的光线照度值
*/
default void onSensorChanged(float lightLux){
}
/**
* 传感器改变事件
* @param dark 是否太暗了，当检测到的光线照度值小于{@link #darkLightLux}时，为{@code true}
* @param lightLux 当前检测到的光线照度值
*/
void onSensorChanged(boolean dark, float lightLux);
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/utils/BeepManager.java
================================================
/*
* Copyright (C) Jenly, MLKit Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.maning.mlkitscanner.scan.utils;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Vibrator;
import com.maning.mlkitscanner.R;
import java.io.Closeable;
/**
* @author Jenly
*/
public final class BeepManager implements MediaPlayer.OnErrorListener, Closeable {
private static final long VIBRATE_DURATION = 200L;
private final Context context;
private MediaPlayer mediaPlayer;
private Vibrator vibrator;
private boolean playBeep;
private boolean vibrate;
public BeepManager(Context context) {
this.context = context;
this.mediaPlayer = null;
updatePrefs();
}
public void setVibrate(boolean vibrate){
this.vibrate = vibrate;
}
public void setPlayBeep(boolean playBeep){
this.playBeep = playBeep;
}
private synchronized void updatePrefs() {
if (mediaPlayer == null) {
mediaPlayer = buildMediaPlayer(context);
}
if(vibrator == null){
vibrator = (Vibrator)context.getSystemService(Context.VIBRATOR_SERVICE);
}
}
public synchronized void playBeepSoundAndVibrate() {
if (playBeep && mediaPlayer != null) {
mediaPlayer.start();
}
if (vibrate) {
vibrator.vibrate(VIBRATE_DURATION);
}
}
private MediaPlayer buildMediaPlayer(Context context) {
MediaPlayer mediaPlayer = new MediaPlayer();
try {
AssetFileDescriptor file = context.getResources().openRawResourceFd(R.raw.mn_scan_beep);
mediaPlayer.setDataSource(file.getFileDescriptor(), file.getStartOffset(), file.getLength());
mediaPlayer.setOnErrorListener(this);
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setLooping(false);
mediaPlayer.prepare();
return mediaPlayer;
} catch (Exception e) {
mediaPlayer.release();
return null;
}
}
@Override
public synchronized boolean onError(MediaPlayer mp, int what, int extra) {
close();
updatePrefs();
return true;
}
@Override
public synchronized void close() {
try{
if (mediaPlayer != null) {
mediaPlayer.release();
mediaPlayer = null;
}
}catch (Exception e){
}
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/utils/CommonUtils.java
================================================
package com.maning.mlkitscanner.scan.utils;
import android.content.Context;
import android.graphics.Paint;
import android.graphics.Rect;
import android.util.DisplayMetrics;
import android.view.WindowManager;
/**
* Created by maning on 2017/11/9.
*/
public class CommonUtils {
/**
* 根据手机分辨率从DP转成PX
*
* @param context
* @param dpValue
* @return
*/
public static int dip2px(Context context, float dpValue) {
float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpValue * scale + 0.5f);
}
/**
* 将sp值转换为px值，保证文字大小不变
*
* @param spValue
* @return
*/
public static int sp2px(Context context, float spValue) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (spValue * fontScale + 0.5f);
}
/**
* 根据手机的分辨率PX(像素)转成DP
*
* @param context
* @param pxValue
* @return
*/
public static int px2dip(Context context, float pxValue) {
float scale = context.getResources().getDisplayMetrics().density;
return (int) (pxValue / scale + 0.5f);
}
/**
* 将px值转换为sp值，保证文字大小不变
*
* @param pxValue
* @return
*/
public static int px2sp(Context context, float pxValue) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (pxValue / fontScale + 0.5f);
}
public static int getScreenWidth(Context context) {
try {
final WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
final DisplayMetrics outMetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(outMetrics);
return outMetrics.widthPixels;
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
public static int getTextWidth(String text, Paint paint){
Rect rect = new Rect();
paint.getTextBounds(text, 0, text.length(), rect);
return rect.width();
}
public static int getTextHeight(String text, Paint paint){
Rect rect = new Rect();
paint.getTextBounds(text, 0, text.length(), rect);
return rect.height();
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/utils/ImageUtils.java
================================================
/*
* Copyright (C) Jenly, MLKit Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.maning.mlkitscanner.scan.utils;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.graphics.YuvImage;
import android.net.Uri;
import android.util.DisplayMetrics;
import androidx.camera.core.ImageProxy;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
/**
* @author Jenly
*/
public class ImageUtils {
private ImageUtils(){
throw new AssertionError();
}
public static Bitmap imageProxyToBitmap(ImageProxy imageProxy) throws Exception {
return imageProxyToBitmap(imageProxy,0);
}
public static Bitmap imageProxyToBitmap(ImageProxy imageProxy, int rotationDegrees) throws Exception {
ImageProxy.PlaneProxy[] plane = imageProxy.getPlanes();
ByteBuffer yBuffer = plane[0].getBuffer(); // Y
ByteBuffer uBuffer = plane[1].getBuffer(); // U
ByteBuffer vBuffer = plane[2].getBuffer(); // V
int ySize = yBuffer.remaining();
int uSize = uBuffer.remaining();
int vSize = vBuffer.remaining();
byte[] nv21 = new byte[ySize + uSize + vSize];
//U and V are swapped
yBuffer.get(nv21, 0, ySize);
vBuffer.get(nv21, ySize, vSize);
uBuffer.get(nv21, ySize + vSize, uSize);
YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21, imageProxy.getWidth(), imageProxy.getHeight(), null);
ByteArrayOutputStream stream = new ByteArrayOutputStream(nv21.length);
yuvImage.compressToJpeg(new Rect(0, 0, yuvImage.getWidth(), yuvImage.getHeight()), 90, stream);
Bitmap bitmap = BitmapFactory.decodeByteArray(stream.toByteArray(), 0, stream.size());
if(rotationDegrees != 0){
Matrix matrix = new Matrix();
matrix.postRotate(rotationDegrees);
bitmap = Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(),bitmap.getHeight(), matrix, true);
}
return bitmap;
}
public static Bitmap getBitmap(Context context,Uri uri){
InputStream Stream = null;
InputStream inputStream = null;
try {
//根据uri获取图片的流
inputStream = context.getContentResolver().openInputStream(uri);
BitmapFactory.Options options = new BitmapFactory.Options();
//options的in系列的设置了，injustdecodebouond只解析图片的大小，而不加载到内存中去
options.inJustDecodeBounds = true;
//1.如果通过options.outHeight获取图片的宽高，就必须通过decodestream解析同options赋值
//否则options.outheight获取不到宽高
BitmapFactory.decodeStream(inputStream,null,options);
//2.通过 btm.getHeight()获取图片的宽高就不需要1的解析，我这里采取第一张方式
// Bitmap btm = BitmapFactory.decodeStream(inputStream);
//以屏幕的宽高进行压缩
DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
int heightPixels = displayMetrics.heightPixels;
int widthPixels = displayMetrics.widthPixels;
//获取图片的宽高
int outHeight = options.outHeight;
int outWidth = options.outWidth;
//heightPixels就是要压缩后的图片高度，宽度也一样
int a = (int) Math.ceil((outHeight/(float)heightPixels));
int b = (int) Math.ceil(outWidth/(float)widthPixels);
//比例计算,一般是图片比较大的情况下进行压缩
int max = Math.max(a, b);
if(max > 1){
options.inSampleSize = max;
}
//解析到内存中去
options.inJustDecodeBounds = false;
// 根据uri重新获取流，inputstream在解析中发生改变了
Stream = context.getContentResolver().openInputStream(uri);
Bitmap bitmap = BitmapFactory.decodeStream(Stream, null, options);
return bitmap;
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(inputStream != null) {
inputStream.close();
}
if(Stream != null){
Stream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/utils/StatusBarUtil.java
================================================
package com.maning.mlkitscanner.scan.utils;
import android.annotation.TargetApi;
import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.os.Build;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.regex.Pattern;
/**
* @author：created by leaf on 2019-05-07
* Github地址：https://github.com/Ye-Miao
* Desc: 状态栏工具类
*/
public class StatusBarUtil {
private static final int DEFAULT_ALPHA = 0;
/**
* 设置状态栏颜色（自定义颜色)
*
* @param activity 目标activity
* @param color 状态栏颜色值
*/
public static void setColor(Activity activity, int color) {
WeakReference activityWeakReference = new WeakReference<>(activity);
setColor(activityWeakReference.get(), color, DEFAULT_ALPHA);
}
/**
* 设置纯色状态栏（自定义颜色，alpha）
*
* @param activity 目标activity
* @param color 状态栏颜色值
* @param alpha 状态栏透明度
*/
public static void setColor(Activity activity, int color, int alpha) {
WeakReference activityWeakReference = new WeakReference<>(activity);
Window window = activityWeakReference.get().getWindow();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.setStatusBarColor(cipherColor(color, alpha));
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
window.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
setTranslucentView((ViewGroup) window.getDecorView(), color, alpha);
setRootView(activityWeakReference.get(), true);
}
}
/**
* 设置状态栏渐变颜色
*
* @param activity 目标activity
* @param view 目标View
*/
public static void setGradientColor(Activity activity, View view) {
WeakReference activityWeakReference = new WeakReference<>(activity);
ViewGroup decorView = (ViewGroup) activityWeakReference.get().getWindow().getDecorView();
View fakeStatusBarView = decorView.findViewById(android.R.id.custom);
if (fakeStatusBarView != null) {
decorView.removeView(fakeStatusBarView);
}
setRootView(activityWeakReference.get(), false);
setTransparentForWindow(activityWeakReference.get());
setPaddingTop(activityWeakReference.get(), view);
}
/**
* 设置透明状态栏
*
* @param activity 目标界面
*/
public static void setTransparentForWindow(Activity activity) {
WeakReference activityWeakReference = new WeakReference<>(activity);
Window window = activityWeakReference.get().getWindow();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.setStatusBarColor(Color.TRANSPARENT);
window.getDecorView()
.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
window.setFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
}
}
/**
* 增加View的paddingTop,增加的值为状态栏高度 (智能判断，并设置高度)
*
* @param context 目标Context
* @param view 需要增高的View
*/
public static void setPaddingTop(Context context, View view) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
ViewGroup.LayoutParams lp = view.getLayoutParams();
if (lp != null && lp.height > 0 && view.getPaddingTop() == 0) {
lp.height += getStatusBarHeight(context);
view.setPadding(view.getPaddingLeft(), view.getPaddingTop() + getStatusBarHeight(context),
view.getPaddingRight(), view.getPaddingBottom());
}
}
}
/**
* 设置状态栏darkMode,字体颜色及icon变黑(目前支持MIUI6以上,Flyme4以上,Android M以上)
*
* @param activity 目标activity
*/
public static void setDarkMode(Activity activity) {
WeakReference activityWeakReference = new WeakReference<>(activity);
darkMode(activityWeakReference.get().getWindow(), true);
}
/**
* 设置状态栏darkMode,字体颜色及icon变亮(目前支持MIUI6以上,Flyme4以上,Android M以上)
*
* @param activity 目标activity
*/
public static void setLightMode(Activity activity) {
WeakReference activityWeakReference = new WeakReference<>(activity);
darkMode(activityWeakReference.get().getWindow(), false);
}
@TargetApi(Build.VERSION_CODES.M)
private static void darkMode(Window window, boolean dark) {
if (isFlyme4()) {
setModeForFlyme4(window, dark);
} else if (isMIUI6()) {
setModeForMIUI6(window, dark);
}
darkModeForM(window, dark);
}
/**
* android 6.0设置字体颜色
*
* @param window 目标window
* @param dark 亮色 or 暗色
*/
private static void darkModeForM(Window window, boolean dark) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
int systemUiVisibility = window.getDecorView().getSystemUiVisibility();
if (dark) {
systemUiVisibility |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
} else {
systemUiVisibility &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
}
window.getDecorView().setSystemUiVisibility(systemUiVisibility);
}
}
/**
* 设置MIUI6+的状态栏的darkMode,darkMode时候字体颜色及icon
* http://dev.xiaomi.com/doc/p=4769/
*
* @param window 目标window
* @param dark 亮色 or 暗色
*/
private static void setModeForMIUI6(Window window, boolean dark) {
Class clazz = window.getClass();
try {
Class layoutParams = Class.forName("android.view.MiuiWindowManager$LayoutParams");
Field field = layoutParams.getField("EXTRA_FLAG_STATUS_BAR_DARK_MODE");
int darkModeFlag = field.getInt(layoutParams);
Method extraFlagField = clazz.getMethod("setExtraFlags", int.class, int.class);
extraFlagField.invoke(window, dark ? darkModeFlag : 0, darkModeFlag);
} catch (Exception e) {
Log.e("StatusBar", "darkIcon: failed");
}
}
/**
* 设置Flyme4+的状态栏的darkMode,darkMode时候字体颜色及icon
* http://open-wiki.flyme.cn/index.php?title=Flyme%E7%B3%BB%E7%BB%9FAPI
*
* @param window 目标window
* @param dark 亮色 or 暗色
*/
private static void setModeForFlyme4(Window window, boolean dark) {
try {
WindowManager.LayoutParams lp = window.getAttributes();
Field darkFlag = WindowManager.LayoutParams.class.getDeclaredField("MEIZU_FLAG_DARK_STATUS_BAR_ICON");
Field meizuFlags = WindowManager.LayoutParams.class.getDeclaredField("meizuFlags");
darkFlag.setAccessible(true);
meizuFlags.setAccessible(true);
int bit = darkFlag.getInt(null);
int value = meizuFlags.getInt(lp);
if (dark) {
value |= bit;
} else {
value &= ~bit;
}
meizuFlags.setInt(lp, value);
window.setAttributes(lp);
} catch (Exception e) {
Log.e("StatusBar", "darkIcon: failed");
}
}
/**
* 判断是否Flyme4以上
*/
private static boolean isFlyme4() {
return Build.FINGERPRINT.contains("Flyme_OS_4") || Build.VERSION.INCREMENTAL.contains("Flyme_OS_4")
|| Pattern.compile("Flyme OS [4|5]", Pattern.CASE_INSENSITIVE).matcher(Build.DISPLAY).find();
}
/**
* 判断是否MIUI6以上
*/
private static boolean isMIUI6() {
try {
Class clz = Class.forName("android.os.SystemProperties");
Method mtd = clz.getMethod("get", String.class);
String val = (String) mtd.invoke(null, "ro.miui.ui.version.name");
val = val.replaceAll("[vV]", "");
int version = Integer.parseInt(val);
return version >= 6;
} catch (Exception e) {
return false;
}
}
/**
* 计算alpha色值
*
* @param color 状态栏颜色值
* @param alpha 状态栏透明度
*/
private static int cipherColor(int color, int alpha) {
if (alpha == 0) {
return color;
}
float a = 1 - alpha / 255f;
int red = color >> 16 & 0xff;
int green = color >> 8 & 0xff;
int blue = color & 0xff;
red = (int) (red * a + 0.5);
green = (int) (green * a + 0.5);
blue = (int) (blue * a + 0.5);
return 0xff << 24 | red << 16 | green << 8 | blue;
}
/**
* 创建透明View
*
* @param viewGroup 目标视图
* @param color 状态栏颜色值
* @param alpha 状态栏透明度
*/
private static void setTranslucentView(ViewGroup viewGroup, int color, int alpha) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
int cipherColor = cipherColor(color, alpha);
View translucentView = viewGroup.findViewById(android.R.id.custom);
if (translucentView == null && cipherColor != 0) {
translucentView = new View(viewGroup.getContext());
translucentView.setId(android.R.id.custom);
ViewGroup.LayoutParams params =
new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, getStatusBarHeight(viewGroup.getContext()));
viewGroup.addView(translucentView, params);
}
if (translucentView != null) {
translucentView.setBackgroundColor(cipherColor);
}
}
}
/**
* 设置根布局参数
*
* @param activity 目标activity
* @param fitSystemWindows 是否预留toolbar的高度
*/
private static void setRootView(Activity activity, boolean fitSystemWindows) {
WeakReference activityWeakReference = new WeakReference<>(activity);
ViewGroup parent = activityWeakReference.get().findViewById(android.R.id.content);
for (int i = 0, count = parent.getChildCount(); i < count; i++) {
View childView = parent.getChildAt(i);
if (childView instanceof ViewGroup) {
childView.setFitsSystemWindows(fitSystemWindows);
((ViewGroup) childView).setClipToPadding(fitSystemWindows);
}
}
}
/**
* 获取状态栏高度
*
* @param context 目标Context
*/
public static int getStatusBarHeight(Context context) {
// 获得状态栏高度
int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
return context.getResources().getDimensionPixelSize(resourceId);
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/utils/ZXingUtils.java
================================================
package com.maning.mlkitscanner.scan.utils;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.Matrix;
import android.text.TextUtils;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.BinaryBitmap;
import com.google.zxing.DecodeHintType;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatReader;
import com.google.zxing.Result;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.QRCodeWriter;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
/**
* Created by maning on 2017/11/10.
*/
public class ZXingUtils {
public static final Map HINTS = new EnumMap<>(DecodeHintType.class);
static {
List allFormats = new ArrayList<>();
allFormats.add(BarcodeFormat.AZTEC);
allFormats.add(BarcodeFormat.CODABAR);
allFormats.add(BarcodeFormat.CODE_39);
allFormats.add(BarcodeFormat.CODE_93);
allFormats.add(BarcodeFormat.CODE_128);
allFormats.add(BarcodeFormat.DATA_MATRIX);
allFormats.add(BarcodeFormat.EAN_8);
allFormats.add(BarcodeFormat.EAN_13);
allFormats.add(BarcodeFormat.ITF);
allFormats.add(BarcodeFormat.MAXICODE);
allFormats.add(BarcodeFormat.PDF_417);
allFormats.add(BarcodeFormat.QR_CODE);
allFormats.add(BarcodeFormat.RSS_14);
allFormats.add(BarcodeFormat.RSS_EXPANDED);
allFormats.add(BarcodeFormat.UPC_A);
allFormats.add(BarcodeFormat.UPC_E);
allFormats.add(BarcodeFormat.UPC_EAN_EXTENSION);
HINTS.put(DecodeHintType.POSSIBLE_FORMATS, allFormats);
HINTS.put(DecodeHintType.CHARACTER_SET, "utf-8");
}
public static Bitmap createQRCodeImage(String content) {
return createQRCodeImage(content, 500, 0, Color.BLACK, Color.WHITE, null, null, null);
}
public static Bitmap createQRCodeImage(String content, int size) {
return createQRCodeImage(content, size, 0, Color.BLACK, Color.WHITE, null, null, null);
}
public static Bitmap createQRCodeImage(String content, int size, int margin) {
return createQRCodeImage(content, size, margin, Color.BLACK, Color.WHITE, null, null, null);
}
public static Bitmap createQRCodeImage(String text, Bitmap logo_bitmap) {
return createQRCodeImage(text, 500, 0, Color.BLACK, Color.WHITE, null, logo_bitmap, null);
}
public static Bitmap createQRCodeImage(String text, int size, Bitmap logo_bitmap) {
return createQRCodeImage(text, size, 0, Color.BLACK, Color.WHITE, null, logo_bitmap, null);
}
public static Bitmap createQRCodeImage(String text, int size, int margin, Bitmap logo_bitmap) {
return createQRCodeImage(text, size, margin, Color.BLACK, Color.WHITE, null, logo_bitmap, null);
}
/**
* 生成带logo的二维码，logo默认为二维码的1/5
*
* @param text 需要生成二维码的内容
* @param size 需要生成二维码的大小
* @param margin 二维码边距
* @param foreground_color 二维码前景色
* @param background_color 二维码背景颜色
* @param error_correction_level 容错率 L：7% M：15% Q：25% H：35%
* @param logo_bitmap logo文件
* @return bitmap
*/
public static Bitmap createQRCodeImage(String text, int size, int margin, int foreground_color, int background_color, String error_correction_level, Bitmap logo_bitmap) {
return createQRCodeImage(text, size, margin, foreground_color, background_color, error_correction_level, logo_bitmap, null);
}
/**
* 生成带logo的二维码，logo默认为二维码的1/5
*
* @param text 需要生成二维码的内容
* @param size 需要生成二维码的大小
* @param margin 二维码边距
* @param foreground_color 二维码前景色
* @param background_color 二维码背景颜色
* @param error_correction_level 容错率 L：7% M：15% Q：25% H：35%
* @param logo_bitmap logo文件
* @param logo_bitmap 二维码前景图片，不建议使用（可能太花识别率会降低）
* @return bitmap
*/
public static Bitmap createQRCodeImage(String text, int size, int margin, int foreground_color, int background_color, String error_correction_level, Bitmap logo_bitmap, Bitmap foreground_bitmap) {
try {
int IMAGE_HALFWIDTH = size / 10;
Hashtable hints = new Hashtable<>();
hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
hints.put(EncodeHintType.MARGIN, Math.max(margin, 0));
/*
* 设置容错级别，默认为ErrorCorrectionLevel.L
* 因为中间加入logo所以建议你把容错级别调至H,否则可能会出现识别不了
*/
if (TextUtils.isEmpty(error_correction_level)) {
if (logo_bitmap != null) {
hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
} else {
hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);
}
} else {
hints.put(EncodeHintType.ERROR_CORRECTION, error_correction_level);
}
BitMatrix bitMatrix = new QRCodeWriter().encode(text,
BarcodeFormat.QR_CODE, size, size, hints);
int width = bitMatrix.getWidth();
int height = bitMatrix.getHeight();
int halfW = width / 2;
int halfH = height / 2;
if (logo_bitmap != null) {
Matrix m = new Matrix();
float sx = (float) 2 * IMAGE_HALFWIDTH / logo_bitmap.getWidth();
float sy = (float) 2 * IMAGE_HALFWIDTH / logo_bitmap.getHeight();
m.setScale(sx, sy);
//设置缩放信息
//将logo图片按martix设置的信息缩放
logo_bitmap = Bitmap.createBitmap(logo_bitmap, 0, 0,
logo_bitmap.getWidth(), logo_bitmap.getHeight(), m, false);
}
if (foreground_bitmap != null) {
//从当前位图按一定的比例创建一个新的位图
foreground_bitmap = Bitmap.createScaledBitmap(foreground_bitmap, width, height, false);
}
int[] pixels = new int[size * size];
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
if (logo_bitmap != null) {
if (x > halfW - IMAGE_HALFWIDTH && x < halfW + IMAGE_HALFWIDTH
&& y > halfH - IMAGE_HALFWIDTH
&& y < halfH + IMAGE_HALFWIDTH) {
//该位置用于存放图片信息
//记录图片每个像素信息
pixels[y * width + x] = logo_bitmap.getPixel(x - halfW
+ IMAGE_HALFWIDTH, y - halfH + IMAGE_HALFWIDTH);
} else {
if (bitMatrix.get(x, y)) {
if (foreground_bitmap != null) {
pixels[y * width + x] = foreground_bitmap.getPixel(x, y);
} else {
pixels[y * width + x] = foreground_color;
}
} else {
pixels[y * size + x] = background_color;
}
}
} else {
if (bitMatrix.get(x, y)) {
if (foreground_bitmap != null) {
pixels[y * width + x] = foreground_bitmap.getPixel(x, y);
} else {
pixels[y * width + x] = foreground_color;
}
} else {
pixels[y * size + x] = background_color;
}
}
}
}
Bitmap bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
bitmap.setPixels(pixels, 0, size, 0, 0, size, size);
return bitmap;
} catch (WriterException e) {
e.printStackTrace();
return null;
}
}
//------解析图片-----
/**
* 同步解析本地图片二维码。该方法是耗时操作，请在子线程中调用。
*
* @param picturePath 要解析的二维码图片本地路径
* @return 返回二维码图片里的内容 或 null
*/
public static String syncDecodeQRCode(String picturePath) {
return syncDecodeQRCode(getDecodeAbleBitmap(picturePath));
}
/**
* 同步解析bitmap二维码。该方法是耗时操作，请在子线程中调用。
*
* @param bitmap 要解析的二维码图片
* @return 返回二维码图片里的内容 或 null
*/
public static String syncDecodeQRCode(Bitmap bitmap) {
try {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
int[] pixels = new int[width * height];
bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
com.google.zxing.RGBLuminanceSource source = new com.google.zxing.RGBLuminanceSource(width, height, pixels);
Result result = new MultiFormatReader().decode(new BinaryBitmap(new HybridBinarizer(source)), HINTS);
if (result != null) {
return recode(result.getText());
} else {
return null;
}
} catch (Exception e) {
return null;
}
}
/**
* 将本地图片文件转换成可解码二维码的 Bitmap
*
* @param picturePath 本地图片文件路径
* @return
*/
private static Bitmap getDecodeAbleBitmap(String picturePath) {
try {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(picturePath, options);
int sampleSize = options.outHeight / 400;
if (sampleSize <= 0) {
sampleSize = 1;
}
options.inSampleSize = sampleSize;
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(picturePath, options);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 中文乱码
*
* @return
*/
public static String recode(String str) {
String formart = "";
try {
boolean ISO = Charset.forName("ISO-8859-1").newEncoder()
.canEncode(str);
if (ISO) {
formart = new String(str.getBytes("ISO-8859-1"), "GB2312");
} else {
formart = str;
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return formart;
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/view/ScanActionMenuView.java
================================================
package com.maning.mlkitscanner.scan.view;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.maning.mlkitscanner.R;
import com.maning.mlkitscanner.scan.callback.MNCustomViewBindCallback;
import com.maning.mlkitscanner.scan.model.MNScanConfig;
/**
* @author : maning
* @date : 2020-09-04
* @desc :
*/
public class ScanActionMenuView extends FrameLayout {
private LinearLayout btn_scan_light;
private ImageView iv_scan_light;
private TextView tv_scan_light;
private LinearLayout btn_close;
private LinearLayout btn_photo;
private RelativeLayout rl_default_menu;
private LinearLayout ll_custom_view;
private OnScanActionMenuListener onScanActionMenuListener;
public interface OnScanActionMenuListener {
void onClose();
void onLight();
void onPhoto();
}
public void setOnScanActionMenuListener(OnScanActionMenuListener onScanActionMenuListener) {
this.onScanActionMenuListener = onScanActionMenuListener;
}
public ScanActionMenuView(Context context) {
this(context, null);
}
public ScanActionMenuView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public ScanActionMenuView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initView();
}
private void initView() {
//绑定
LayoutInflater.from(getContext()).inflate(R.layout.mn_scan_action_menu, this);
btn_scan_light = (LinearLayout) findViewById(R.id.btn_scan_light);
iv_scan_light = (ImageView) findViewById(R.id.iv_scan_light);
tv_scan_light = (TextView) findViewById(R.id.tv_scan_light);
btn_close = (LinearLayout) findViewById(R.id.btn_close);
btn_photo = (LinearLayout) findViewById(R.id.btn_photo);
rl_default_menu = (RelativeLayout) findViewById(R.id.rl_default_menu);
ll_custom_view = (LinearLayout) findViewById(R.id.ll_custom_view);
rl_default_menu.setVisibility(View.GONE);
ll_custom_view.setVisibility(View.GONE);
//点击事件
btn_scan_light.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (onScanActionMenuListener != null) {
onScanActionMenuListener.onLight();
}
}
});
btn_close.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (onScanActionMenuListener != null) {
onScanActionMenuListener.onClose();
}
}
});
btn_photo.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (onScanActionMenuListener != null) {
onScanActionMenuListener.onPhoto();
}
}
});
}
private MNScanConfig scanConfig;
public void setScanConfig(MNScanConfig config, MNCustomViewBindCallback customViewBindCallback) {
this.scanConfig = config;
//自定义View
int customShadeViewLayoutID = scanConfig.getCustomShadeViewLayoutID();
if (customShadeViewLayoutID > 0 && customViewBindCallback != null) {
//显示出来
ll_custom_view.setVisibility(View.VISIBLE);
View customView = LayoutInflater.from(getContext()).inflate(customShadeViewLayoutID, null);
ll_custom_view.addView(customView);
//事件绑定
customViewBindCallback.onBindView(customView);
} else {
rl_default_menu.setVisibility(View.VISIBLE);
}
//闪光灯配置
boolean showLightController = scanConfig.isShowLightController();
if (showLightController) {
btn_scan_light.setVisibility(View.VISIBLE);
} else {
btn_scan_light.setVisibility(View.GONE);
}
//其他配置
if (!scanConfig.isShowPhotoAlbum()) {
btn_photo.setVisibility(View.GONE);
}
}
public void openLight() {
iv_scan_light.setImageResource(R.drawable.mn_icon_scan_flash_light_on);
tv_scan_light.setText("关闭手电筒");
}
public void closeLight() {
iv_scan_light.setImageResource(R.drawable.mn_icon_scan_flash_light_off);
tv_scan_light.setText("打开手电筒");
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/view/ScanResultPointView.java
================================================
package com.maning.mlkitscanner.scan.view;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Rect;
import android.graphics.drawable.GradientDrawable;
import android.os.Build;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.google.mlkit.vision.barcode.common.Barcode;
import com.maning.mlkitscanner.R;
import com.maning.mlkitscanner.scan.model.MNScanConfig;
import com.maning.mlkitscanner.scan.utils.CommonUtils;
import com.maning.mlkitscanner.scan.utils.StatusBarUtil;
import java.util.List;
import static android.graphics.drawable.GradientDrawable.RECTANGLE;
/**
* @author : maning
* @date : 2021/1/7
* @desc : 扫描结果点View展示
*/
public class ScanResultPointView extends FrameLayout {
private MNScanConfig scanConfig;
private List resultPoint;
private OnResultPointClickListener onResultPointClickListener;
private int resultPointColor;
private int resultPointStrokeColor;
private int resultPointWithdHeight;
private int resultPointRadiusCorners;
private int resultPointStrokeWidth;
private TextView tv_cancle;
private FrameLayout fl_result_point_root;
private View fakeStatusBar;
private int statusBarHeight;
private ImageView iv_show_result;
private Bitmap barcodeBitmap;
public void setOnResultPointClickListener(OnResultPointClickListener onResultPointClickListener) {
this.onResultPointClickListener = onResultPointClickListener;
}
public interface OnResultPointClickListener {
void onPointClick(String result);
void onCancle();
}
public ScanResultPointView(Context context) {
this(context, null);
}
public ScanResultPointView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public ScanResultPointView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initView();
}
private void initView() {
View view = LayoutInflater.from(getContext()).inflate(R.layout.mn_scan_result_point_view, this);
fakeStatusBar = view.findViewById(R.id.fakeStatusBar2);
iv_show_result = view.findViewById(R.id.iv_show_result);
tv_cancle = view.findViewById(R.id.tv_cancle);
fl_result_point_root = view.findViewById(R.id.fl_result_point_root);
statusBarHeight = StatusBarUtil.getStatusBarHeight(getContext());
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
ViewGroup.LayoutParams fakeStatusBarLayoutParams = fakeStatusBar.getLayoutParams();
fakeStatusBarLayoutParams.height = statusBarHeight;
fakeStatusBar.setLayoutParams(fakeStatusBarLayoutParams);
}
tv_cancle.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//隐藏View
if (onResultPointClickListener != null) {
onResultPointClickListener.onCancle();
}
removeAllPoints();
}
});
iv_show_result.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//拦截点击事件
}
});
}
public void setScanConfig(MNScanConfig config) {
scanConfig = config;
initResultPointConfigs();
}
private void initResultPointConfigs() {
if (scanConfig == null) {
return;
}
resultPointRadiusCorners = CommonUtils.dip2px(getContext(), scanConfig.getResultPointCorners());
resultPointWithdHeight = CommonUtils.dip2px(getContext(), scanConfig.getResultPointWithdHeight());
resultPointStrokeWidth = CommonUtils.dip2px(getContext(), scanConfig.getResultPointStrokeWidth());
String resultPointColorStr = scanConfig.getResultPointColor();
String resultPointStrokeColorStr = scanConfig.getResultPointStrokeColor();
if (resultPointWithdHeight == 0) {
resultPointWithdHeight = CommonUtils.dip2px(getContext(), 36);
}
if (resultPointRadiusCorners == 0) {
resultPointRadiusCorners = CommonUtils.dip2px(getContext(), 36);
}
if (resultPointStrokeWidth == 0) {
resultPointStrokeWidth = CommonUtils.dip2px(getContext(), 3);
}
if (!TextUtils.isEmpty(resultPointColorStr)) {
resultPointColor = Color.parseColor(resultPointColorStr);
} else {
resultPointColor = getContext().getResources().getColor(R.color.mn_scan_viewfinder_laser_result_point);
}
if (!TextUtils.isEmpty(resultPointStrokeColorStr)) {
resultPointStrokeColor = Color.parseColor(resultPointStrokeColorStr);
} else {
resultPointStrokeColor = getContext().getResources().getColor(R.color.mn_scan_viewfinder_laser_result_point_border);
}
}
public void setDatas(List results, Bitmap barcode) {
this.resultPoint = results;
this.barcodeBitmap = barcode;
drawableResultPoint();
}
public void removeAllPoints() {
fl_result_point_root.removeAllViews();
}
private void drawableResultPoint() {
Log.e(">>>>>>", "drawableResultPoint---start");
iv_show_result.setImageBitmap(barcodeBitmap);
removeAllPoints();
if (resultPoint == null || resultPoint.size() == 0) {
if (onResultPointClickListener != null) {
onResultPointClickListener.onCancle();
}
return;
}
if (scanConfig == null) {
scanConfig = new MNScanConfig.Builder().builder();
}
if (resultPoint.size() == 1) {
tv_cancle.setVisibility(View.INVISIBLE);
} else {
tv_cancle.setVisibility(View.VISIBLE);
}
for (int j = 0; j < resultPoint.size(); j++) {
Barcode barcode = resultPoint.get(j);
Rect boundingBox = barcode.getBoundingBox();
int centerX = boundingBox.centerX();
int centerY = boundingBox.centerY();
View inflate = LayoutInflater.from(getContext()).inflate(R.layout.mn_scan_result_point_item_view, null);
RelativeLayout rl_root = inflate.findViewById(R.id.rl_root);
ImageView iv_point_bg = inflate.findViewById(R.id.iv_point_bg);
ImageView iv_point_arrow = inflate.findViewById(R.id.iv_point_arrow);
//位置
RelativeLayout.LayoutParams lpRoot = new RelativeLayout.LayoutParams(resultPointWithdHeight, resultPointWithdHeight);
rl_root.setLayoutParams(lpRoot);
rl_root.setX(centerX - resultPointWithdHeight / 2.0f);
rl_root.setY(centerY - resultPointWithdHeight / 2.0f);
GradientDrawable gradientDrawable = new GradientDrawable();
gradientDrawable.setCornerRadius(resultPointRadiusCorners);
gradientDrawable.setShape(RECTANGLE);
gradientDrawable.setStroke(resultPointStrokeWidth, resultPointStrokeColor);
gradientDrawable.setColor(resultPointColor);
iv_point_bg.setImageDrawable(gradientDrawable);
//点的大小
ViewGroup.LayoutParams lpPoint = iv_point_bg.getLayoutParams();
lpPoint.width = resultPointWithdHeight;
lpPoint.height = resultPointWithdHeight;
iv_point_bg.setLayoutParams(lpPoint);
//箭头大小
if (resultPoint.size() > 1) {
ViewGroup.LayoutParams lpArrow = iv_point_arrow.getLayoutParams();
lpArrow.width = resultPointWithdHeight / 2;
lpArrow.height = resultPointWithdHeight / 2;
iv_point_arrow.setLayoutParams(lpArrow);
iv_point_arrow.setVisibility(View.VISIBLE);
} else {
//一个不需要箭头
iv_point_arrow.setVisibility(View.GONE);
}
iv_point_bg.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if (onResultPointClickListener != null) {
onResultPointClickListener.onPointClick(barcode.getDisplayValue());
}
}
});
fl_result_point_root.addView(inflate);
}
int childCount = fl_result_point_root.getChildCount();
Log.e(">>>>>>", "fl_result_point_root---childCount：" + childCount);
if (childCount <= 0) {
//关闭页面
if (onResultPointClickListener != null) {
onResultPointClickListener.onCancle();
}
}
Log.e(">>>>>>", "drawableResultPoint---end");
}
}
================================================
FILE: mlkit-scanner/src/main/java/com/maning/mlkitscanner/scan/view/ViewfinderView.java
================================================
/*
* Copyright (C) 2008 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.maning.mlkitscanner.scan.view;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.View;
import com.maning.mlkitscanner.R;
import com.maning.mlkitscanner.scan.model.MNScanConfig;
import com.maning.mlkitscanner.scan.utils.CommonUtils;
/**
* This view is overlaid on top of the camera preview. It adds the viewfinder rectangle and partial
* transparency outside it, as well as the laser scanner animation and result points.
*
* @author dswitkin@google.com (Daniel Switkin)
*/
public final class ViewfinderView extends View {
private static final String TAG = "ViewfinderView";
private final Paint paint;
private Paint paintResultPoint;
private Paint paintText;
private Paint paintTextBg;
private Paint paintLine;
private Paint paintLaser;
private int maskColor;
private int laserColor;
private Rect frame;
private String hintMsg;
private String hintTextColor = "#FFFFFF";
private int hintTextSize = 13;
private int linePosition = 0;
private int margin;
private int laserLineW;
private int cornerLineH;
private int cornerLineW;
private int gridColumn;
private int gridHeight;
//扫描线风格：0线，1网格
private MNScanConfig.LaserStyle laserStyle = MNScanConfig.LaserStyle.Line;
private MNScanConfig mnScanConfig;
private ValueAnimator anim;
private boolean needAnimation = true;
public ViewfinderView(Context context, AttributeSet attrs) {
super(context, attrs);
// Initialize these once for performance rather than calling them every time in onDraw().
paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paintResultPoint = new Paint(Paint.ANTI_ALIAS_FLAG);
paintText = new Paint(Paint.ANTI_ALIAS_FLAG);
paintTextBg = new Paint(Paint.ANTI_ALIAS_FLAG);
paintLine = new Paint(Paint.ANTI_ALIAS_FLAG);
paintLaser = new Paint(Paint.ANTI_ALIAS_FLAG);
Resources resources = getResources();
maskColor = resources.getColor(R.color.mn_scan_viewfinder_mask);
laserColor = resources.getColor(R.color.mn_scan_viewfinder_laser);
hintMsg = "扫二维码/条形码";
//文字
paintText.setColor(Color.WHITE);
paintText.setTextSize(CommonUtils.sp2px(getContext(), hintTextSize));
paintText.setTextAlign(Paint.Align.CENTER);
paintTextBg.setColor(laserColor);
paintTextBg.setTextAlign(Paint.Align.CENTER);
//四角
paintLine.setColor(laserColor);
//扫描线
paintLaser.setColor(laserColor);
paintResultPoint.setColor(laserColor);
//初始化数据大小
initSize();
}
private void initSize() {
//间距
margin = CommonUtils.dip2px(getContext(), 4);
//扫描线的宽度
laserLineW = CommonUtils.dip2px(getContext(), 4);
//四角线块
cornerLineH = CommonUtils.dip2px(getContext(), 2);
cornerLineW = CommonUtils.dip2px(getContext(), 14);
//网格扫描线先关配置
gridColumn = 24;
gridHeight = CommonUtils.getScreenWidth(getContext()) * 7 / 10;
}
/**
* 设置颜色
*
* @param laserColor
*/
public void setLaserColor(int laserColor) {
this.laserColor = laserColor;
paintLine.setColor(this.laserColor);
paintLaser.setColor(this.laserColor);
}
/**
* 扫描线的样式
*
* @param laserStyle
*/
public void setLaserStyle(MNScanConfig.LaserStyle laserStyle) {
this.laserStyle = laserStyle;
}
/**
* 背景色
*
* @param maskColor
*/
public void setMaskColor(int maskColor) {
this.maskColor = maskColor;
}
/**
* 网格扫描列数
*
* @param gridColumn
*/
public void setGridScannerColumn(int gridColumn) {
if (gridColumn > 0) {
this.gridColumn = gridColumn;
}
}
/**
* 网格扫描高度，默认扫描框的高度
*
* @param gridHeight
*/
public void setGridScannerHeight(int gridHeight) {
this.gridHeight = gridHeight;
}
public void setScanConfig(MNScanConfig scanConfig) {
this.mnScanConfig = scanConfig;
//扫描文字配置
setHintText(mnScanConfig.getScanHintText(), mnScanConfig.getScanHintTextColor(), mnScanConfig.getScanHintTextSize());
//扫描线相关配置
if (!TextUtils.isEmpty(mnScanConfig.getScanColor())) {
setLaserColor(Color.parseColor(mnScanConfig.getScanColor()));
}
setLaserStyle(mnScanConfig.getLaserStyle());
if (!TextUtils.isEmpty(mnScanConfig.getBgColor())) {
setMaskColor(Color.parseColor(mnScanConfig.getBgColor()));
}
setGridScannerColumn(mnScanConfig.getGridScanLineColumn());
setGridScannerHeight(mnScanConfig.getGridScanLineHeight());
}
/**
* 设置文案
*/
public void setHintText(String hintMsg, String hintTextColor, int hintTextSize) {
//文字
if (!TextUtils.isEmpty(hintMsg)) {
this.hintMsg = hintMsg;
} else {
this.hintMsg = "";
}
//文字颜色
if (!TextUtils.isEmpty(hintTextColor)) {
this.hintTextColor = hintTextColor;
}
//文字大小
if (hintTextSize > 0) {
this.hintTextSize = hintTextSize;
}
paintText.setColor(Color.parseColor(this.hintTextColor));
paintText.setTextSize(CommonUtils.sp2px(getContext(), this.hintTextSize));
}
@SuppressLint("DrawAllocation")
@Override
public void onDraw(Canvas canvas) {
int width = canvas.getWidth();
int height = canvas.getHeight();
int txtMargin = CommonUtils.dip2px(getContext(), 20);
int frameWidth = (int) (width * this.mnScanConfig.getScanFrameSizeScale());
if (mnScanConfig != null && mnScanConfig.isFullScreenScan()) {
frameWidth = width * 9 / 10;
}
int left = (width - frameWidth) / 2;
int top = (height - frameWidth) / 2;
frame = new Rect(left, top, left + frameWidth, top + frameWidth);
//重新赋值
frame.top = (height - (frame.right - frame.left)) / 2;
frame.bottom = frame.top + (frame.right - frame.left);
frame.left = (width - (frame.right - frame.left)) / 2;
frame.right = frame.left + (frame.right - frame.left);
paintLine.setShader(null);
//四角线块
int rectH = cornerLineW;
int rectW = cornerLineH;
//判断是不是全屏模式
if (mnScanConfig != null && mnScanConfig.isFullScreenScan()) {
//全屏透明
paint.setColor(Color.TRANSPARENT);
canvas.drawRect(0, 0, width, height, paint);
//扫描线的宽度
laserLineW = CommonUtils.dip2px(getContext(), 4);
} else {
//扫描线的宽度
laserLineW = CommonUtils.dip2px(getContext(), 2);
// 半透明背景
paint.setColor(maskColor);
canvas.drawRect(0, 0, width, frame.top, paint);
canvas.drawRect(0, frame.top, frame.left, frame.bottom + 1, paint);
canvas.drawRect(frame.right + 1, frame.top, width, frame.bottom + 1, paint);
canvas.drawRect(0, frame.bottom + 1, width, height, paint);
//左上角
canvas.drawRect(frame.left, frame.top, frame.left + rectW, frame.top + rectH, paintLine);
canvas.drawRect(frame.left, frame.top, frame.left + rectH, frame.top + rectW, paintLine);
//右上角
canvas.drawRect(frame.right - rectW, frame.top, frame.right + 1, frame.top + rectH, paintLine);
canvas.drawRect(frame.right - rectH, frame.top, frame.right + 1, frame.top + rectW, paintLine);
//左下角
canvas.drawRect(frame.left, frame.bottom - rectH, frame.left + rectW, frame.bottom + 1, paintLine);
canvas.drawRect(frame.left, frame.bottom - rectW, frame.left + rectH, frame.bottom + 1, paintLine);
//右下角
canvas.drawRect(frame.right - rectW, frame.bottom - rectH, frame.right + 1, frame.bottom + 1, paintLine);
canvas.drawRect(frame.right - rectH, frame.bottom - rectW, frame.right + 1, frame.bottom + 1, paintLine);
}
//带有背景框的文字，暂时不做
// float textWidth = CommonUtils.getTextWidth(hintMsg, paintText);
// float textHeight = CommonUtils.getTextHeight(hintMsg, paintText);
// float startX = (width - textWidth) / 2 - CommonUtils.dip2px(getContext(), 20);
// float startY = frame.bottom + txtMargin;
// float endX = startX + textWidth + CommonUtils.dip2px(getContext(), 40);
// float endY = startY + textHeight + CommonUtils.dip2px(getContext(), 12);
// RectF rectF = new RectF(startX, startY, endX, endY);
// canvas.drawRoundRect(rectF, 100, 100, paintTextBg);
// if (mnScanConfig.isSupportZoom() && mnScanConfig.isShowZoomController() && mnScanConfig.getZoomControllerLocation() == MNScanConfig.ZoomControllerLocation.Bottom) {
// canvas.drawText(hintMsg, width / 2, frame.top - txtMargin, paintText);
// } else {
// canvas.drawText(hintMsg, width / 2, startY + (rectF.height() - textHeight) + (rectF.height() - textHeight) / 2f, paintText);
// }
//文字
canvas.drawText(hintMsg, width / 2, frame.bottom + txtMargin + CommonUtils.getTextHeight(hintMsg, paintText), paintText);
//中间的线：动画
if (linePosition <= 0) {
linePosition = frame.top + margin;
}
//扫描线
if (laserStyle == MNScanConfig.LaserStyle.Line) {
drawLineScanner(canvas, frame);
} else if (laserStyle == MNScanConfig.LaserStyle.Grid) {
drawGridScanner(canvas, frame);
}
//动画刷新
startAnimation();
}
/**
* 绘制线性式扫描
*
* @param canvas
* @param frame
*/
private void drawLineScanner(Canvas canvas, Rect frame) {
//线性渐变
LinearGradient linearGradient = new LinearGradient(
frame.left, linePosition,
frame.left, linePosition + laserLineW,
shadeColor(laserColor),
laserColor,
Shader.TileMode.MIRROR);
paintLine.setShader(linearGradient);
RectF rect = new RectF(frame.left + margin, linePosition, frame.right - margin, linePosition + laserLineW);
canvas.drawOval(rect, paintLaser);
}
/**
* 绘制网格式扫描
*
* @param canvas
* @param frame
*/
private void drawGridScanner(Canvas canvas, Rect frame) {
if (gridHeight <= 0) {
gridHeight = frame.bottom - frame.top;
}
int stroke = 2;
paintLaser.setStrokeWidth(stroke);
//计算Y轴开始位置
int startY;
if (gridHeight > 0 && linePosition - frame.top > gridHeight) {
startY = linePosition - gridHeight;
} else {
startY = frame.top;
}
LinearGradient linearGradient = new LinearGradient(frame.left + frame.width() / 2, startY, frame.left + frame.width() / 2, linePosition, new int[]{shadeColor(laserColor), laserColor}, new float[]{0, 1f}, LinearGradient.TileMode.CLAMP);
//给画笔设置着色器
paintLaser.setShader(linearGradient);
float wUnit = frame.width() * 1.0f / gridColumn;
float hUnit = wUnit;
//遍历绘制网格纵线
for (int i = 0; i <= gridColumn; i++) {
float startX;
float stopX;
if (i == 0) {
startX = frame.left + 1;
} else if (i == gridColumn) {
startX = frame.left + i * wUnit - 1;
} else {
startX = frame.left + i * wUnit;
}
stopX = startX;
canvas.drawLine(startX, startY, stopX, linePosition, paintLaser);
}
int height = gridHeight > 0 && linePosition - frame.top > gridHeight ? gridHeight : linePosition - frame.top;
//遍历绘制网格横线
for (int i = 0; i <= height / hUnit; i++) {
canvas.drawLine(frame.left, linePosition - i * hUnit, frame.right, linePosition - i * hUnit, paintLaser);
}
}
/**
* 处理颜色模糊
*
* @param color
* @return
*/
public int shadeColor(int color) {
String hax = Integer.toHexString(color);
String result = "01" + hax.substring(2);
return Integer.valueOf(result, 16);
}
public void startAnimation() {
if (anim != null) {
return;
}
anim = ValueAnimator.ofInt(frame.top - 2, frame.bottom + 2);
anim.setRepeatCount(ValueAnimator.INFINITE);
anim.setRepeatMode(ValueAnimator.RESTART);
anim.setDuration(2400);
anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
if (!needAnimation) {
return;
}
linePosition = (int) animation.getAnimatedValue();
try {
postInvalidate(
frame.left - 2,
frame.top - 2,
frame.right + 2,
frame.bottom + 2);
} catch (Exception e) {
postInvalidate();
}
}
});
anim.start();
}
public void destroyView() {
if (anim != null) {
anim.removeAllUpdateListeners();
anim.cancel();
anim.end();
anim = null;
}
}
}
================================================
FILE: mlkit-scanner/src/main/res/anim/mn_scan_activity_bottom_in.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/anim/mn_scan_activity_bottom_out.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/drawable/mn_scan_result_point_default.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/layout/mn_scan_action_menu.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/layout/mn_scan_activity_scan_preview.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/layout/mn_scan_result_point_item_view.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/layout/mn_scan_result_point_view.xml
================================================
================================================
FILE: mlkit-scanner/src/main/res/values/colors.xml
================================================
#FFff3535
#80000000
#CCFF3535
#FFFFFFFF
================================================
FILE: mlkit-scanner/src/main/res/values/styles.xml
================================================
================================================
FILE: settings.gradle
================================================
include ':mlkit-scanner'
include ':app'
rootProject.name = "MNMLKitScanner"
