Android 接入微信扫码库，实现堪比微信的扫码效果_微信二维码识别sdk

对于Android的扫码库，我们平时都会使用ZXing或者ZBar来实现。

但是实际情况是，对于一些环境恶劣的情况下，比如 眩光、昏暗、有污渍等情况下，很难被识别。

即使是在普通情况下，扫码的识别速度、识别率依旧不甚满意的。

为了满足业务需要，故我们需要找到更好的扫码库。

微信开源的扫码库，就是其中一个不错的选择。

微信的扫码库，基于开源引擎ZXing，结合计算机视觉和深度学习技术，深度优化改造的高性能扫码库。

拥有 基于CNN的二维码检测和增强，更鲁棒的定位点检测，更详细的特性可以看基于CNN的微信二维码引擎OpenCV开源！

接入微信扫码库

接入微信扫码库，需要接入OpenCV库，接入OpenCV库有以下几种方式

• 接入OpenCV的Java SDK包，这样可以直接在Java调用OpenCV的大部分方法，这种方法最简单
• 使用OpenCV sdk 提供的C++头文件与.so动态库、.a静态库，自己封装jni，这样可以100%使用openCV的接口
• 通过openCV的源码，重新编译成Android sdk库，这样能只编译生成自己需要的功能，文件比较小，缺点是编译环境啥的比较难搞。

关于OpenCV不同接入方式，详情请看 Android 接入 OpenCV库的三种方式

这里，我直接用方法一 + 方法二的形式，首先我们需要下载OpenCV的SDK包，附上下载地址

这里选择的是OpenCV 4.5.2版本，选择android进行下载

下载完成解压后，我们得到了如下所示的文件

这里的sdk文件夹，就是我们需要的OpenCV的Java SDK包了。

接着，我们新建一个项目，选择Native C++

接着，我们导入这个Java SDK

接着，在app的gradle中，依赖这个library

implementation project(':sdk')
1

新建一个WeChatQRCode的扫码类，这里有三个jni接口

• WeChatQrCode : 初始化
• detectAndDecode : 发现并解析
• delete : 销毁

class WeChatQRCode {
    
    val nativeObjAddr: Long

    private constructor(addr: Long) {
        nativeObjAddr = addr
    }

    constructor(
        detector_prototxt_path: String,
        detector_caffe_model_path: String,
        super_resolution_prototxt_path: String,
        super_resolution_caffe_model_path: String
    ) {
        nativeObjAddr = WeChatQRCode(
            detector_prototxt_path,
            detector_caffe_model_path,
            super_resolution_prototxt_path,
            super_resolution_caffe_model_path
        )
    }

    fun detectAndDecode(img: Mat, points: List<Mat>): List<String> {
        val points_mat = Mat()
        val retVal = detectAndDecode(
            nativeObjAddr, img.nativeObj, points_mat.nativeObjAddr
        )
        Converters.Mat_to_vector_Mat(points_mat, points)
        points_mat.release()
        return retVal
    }

    @Throws(Throwable::class)
    protected fun finalize() {
        delete(nativeObjAddr)
    }

    external fun WeChatQRCode(
        detector_prototxt_path: String,
        detector_caffe_model_path: String,
        super_resolution_prototxt_path: String,
        super_resolution_caffe_model_path: String
    ): Long


    external fun detectAndDecode(
        nativeObj: Long,
        img_nativeObj: Long,
        points_mat_nativeObj: Long
    ): List<String>


    external fun delete(nativeObj: Long)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

在app模块的cpp文件夹中，添加头文件

• 复制OpenCV-android-sdk\sdk\native\jni\include下的opencv2文件夹到cpp文件夹下
• 复制 wechat_qrcode.hpp到cpp/opencv2文件夹下
• 复制opencv_contrib/modules/wechat_qrcode/src/下的文件到cpp目录下

同时，我们在native-lib.cpp中，实现jni方法

#include <jni.h>
#include <string>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/wechat_qrcode.hpp>
#include <opencv2/imgcodecs.hpp>
#include <android/log.h>


#define CONSTRUCTOR(ENV, CLS) ENV->GetMethodID(CLS, "<init>", "(I)V")
#define ARRAYLIST(ENV) static_cast<jclass>(ENV->NewGlobalRef(ENV->FindClass("java/util/ArrayList")))
#define LIST_ADD(ENV, LIST) ENV->GetMethodID(LIST, "add", "(Ljava/lang/Object;)Z")

#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, "NativeLib", __VA_ARGS__)
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG , "NativeLib", __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO  , "NativeLib", __VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN  , "NativeLib", __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR  , "NativeLib", __VA_ARGS__)


using namespace std;
using namespace cv;


/// throw java exception
#undef throwJavaException
#define throwJavaException throwJavaException_wechat_qrcode

static void throwJavaException(JNIEnv *env, const std::exception *e, const char *method) {
    std::string what = "unknown exception";
    jclass je = 0;

    if (e) {
        std::string exception_type = "std::exception";

        if (dynamic_cast<const cv::Exception *>(e)) {
            exception_type = "cv::Exception";
            je = env->FindClass("org/opencv/core/CvException");
        }

        what = exception_type + ": " + e->what();
    }

    if (!je) je = env->FindClass("java/lang/Exception");
    env->ThrowNew(je, what.c_str());

    LOGE("%s caught %s", method, what.c_str());
    (void) method;        // avoid "unused" warning
}


void vector_Mat_to_Mat(std::vector<cv::Mat> &v_mat, cv::Mat &mat) {
    int count = (int) v_mat.size();
    mat.create(count, 1, CV_32SC2);
    for (int i = 0; i < count; i++) {
        long long addr = (long long) new Mat(v_mat[i]);
        mat.at<Vec<int, 2> >(i, 0) = Vec<int, 2>(addr >> 32, addr & 0xffffffff);
    }
}


jobject vector_string_to_List(JNIEnv *env, std::vector<std::string> &vs) {

    static jclass juArrayList = ARRAYLIST(env);
    static jmethodID m_create = CONSTRUCTOR(env, juArrayList);
    jmethodID m_add = LIST_ADD(env, juArrayList);

    jobject result = env->NewObject(juArrayList, m_create, vs.size());
    for (std::vector<std::string>::iterator it = vs.begin(); it != vs.end(); ++it) {
        jstring element = env->NewStringUTF((*it).c_str());
        env->CallBooleanMethod(result, m_add, element);
        env->DeleteLocalRef(element);
    }
    return result;
}

extern "C"
JNIEXPORT jlong JNICALL
Java_com_heiko_opencvwxtest_WeChatQRCode_WeChatQRCode(JNIEnv *env, jobject thiz,
                                                      jstring detector_prototxt_path,
                                                      jstring detector_caffe_model_path,
                                                      jstring super_resolution_prototxt_path,
                                                      jstring super_resolution_caffe_model_path) {
    using namespace cv::wechat_qrcode;
    static const char method_name[] = "WeChatQRCode_WeChatQRCode";
    try {
        LOGD("%s", method_name);
        const char *utf_detector_prototxt_path = env->GetStringUTFChars(detector_prototxt_path, 0);
        std::string n_detector_prototxt_path(
                utf_detector_prototxt_path ? utf_detector_prototxt_path : "");
        env->ReleaseStringUTFChars(detector_prototxt_path, utf_detector_prototxt_path);
        const char *utf_detector_caffe_model_path = env->GetStringUTFChars(
                detector_caffe_model_path, 0);
        std::string n_detector_caffe_model_path(
                utf_detector_caffe_model_path ? utf_detector_caffe_model_path : "");
        env->ReleaseStringUTFChars(detector_caffe_model_path, utf_detector_caffe_model_path);
        const char *utf_super_resolution_prototxt_path = env->GetStringUTFChars(
                super_resolution_prototxt_path, 0);
        std::string n_super_resolution_prototxt_path(
                utf_super_resolution_prototxt_path ? utf_super_resolution_prototxt_path : "");
        env->ReleaseStringUTFChars(super_resolution_prototxt_path,
                                   utf_super_resolution_prototxt_path);
        const char *utf_super_resolution_caffe_model_path = env->GetStringUTFChars(
                super_resolution_caffe_model_path, 0);
        std::string n_super_resolution_caffe_model_path(
                utf_super_resolution_caffe_model_path ? utf_super_resolution_caffe_model_path : "");
        env->ReleaseStringUTFChars(super_resolution_caffe_model_path,
                                   utf_super_resolution_caffe_model_path);
        cv::wechat_qrcode::WeChatQRCode *_retval_ = new cv::wechat_qrcode::WeChatQRCode(
                n_detector_prototxt_path, n_detector_caffe_model_path,
                n_super_resolution_prototxt_path, n_super_resolution_caffe_model_path);
        return (jlong) _retval_;
    } catch (const std::exception &e) {
        throwJavaException(env, &e, method_name);
    } catch (...) {
        throwJavaException(env, 0, method_name);
    }
    return 0;
}

extern "C"
JNIEXPORT jobject JNICALL
Java_com_heiko_opencvwxtest_WeChatQRCode_detectAndDecode(JNIEnv *env,
                                                         jobject thiz,
                                                         jlong self,
                                                         jlong img_nativeObj,
                                                         jlong points_mat_nativeObj) {
    using namespace cv::wechat_qrcode;
    static const char method_name[] = "WeChatQRCode_detectAndDecode";
    try {
        LOGD("%s", method_name);
        std::vector<Mat> points;
        Mat &points_mat = *((Mat *) points_mat_nativeObj);
        cv::wechat_qrcode::WeChatQRCode *me = (cv::wechat_qrcode::WeChatQRCode *) self;
        Mat &img = *((Mat *) img_nativeObj);
        std::vector<std::string> _ret_val_vector_ = me->detectAndDecode(img, points);
        vector_Mat_to_Mat(points, points_mat);
        jobject _retval_ = vector_string_to_List(env, _ret_val_vector_);
        return _retval_;
    } catch (const std::exception &e) {
        throwJavaException(env, &e, method_name);
    } catch (...) {
        throwJavaException(env, 0, method_name);
    }
    return 0;
}

extern "C"
JNIEXPORT void JNICALL
Java_com_heiko_opencvwxtest_WeChatQRCode_delete(JNIEnv *env, jobject thiz, jlong self) {
    delete (cv::wechat_qrcode::WeChatQRCode *) self;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

修改CMakeLists.txt文件

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.10.2)

# Declares and names the project.

project("learningandroidopencv")

# 注意这里的路径，需要和OpenCV sdk的路径对应
set(ocvlibs "${PROJECT_SOURCE_DIR}/../../../../sdk/native/libs")
include_directories(${PROJECT_SOURCE_DIR}/include)

add_library(libopencv_java4 SHARED IMPORTED)
set_target_properties(libopencv_java4 PROPERTIES
        IMPORTED_LOCATION "${ocvlibs}/${ANDROID_ABI}/libopencv_java4.so")

include_directories(
        wechat
        wechat/detector
        wechat/scale
        wechat/zxing
        wechat/zxing/common
        wechat/zxing/common/binarizer
        wechat/zxing/common/reedsolomon
        wechat/zxing/qrcode
        wechat/zxing/qrcode/detector
        wechat/zxing/qrcode/decoder
)

aux_source_directory(wechat W)
aux_source_directory(wechat/detector WD)
aux_source_directory(wechat/scale WS)
aux_source_directory(wechat/zxing WZ)
aux_source_directory(wechat/zxing/common WZC)
aux_source_directory(wechat/zxing/common/binarizer WZCB)
aux_source_directory(wechat/zxing/common/reedsolomon WZCR)
aux_source_directory(wechat/zxing/qrcode WZQ)
aux_source_directory(wechat/zxing/qrcode/decoder WZQD)
aux_source_directory(wechat/zxing/qrcode/detector WZQD2)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

add_library( # Sets the name of the library.
        native-lib

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        native-lib.cpp
        ${W}
        ${WD}
        ${WS}
        ${WZ}
        ${WZC}
        ${WZCB}
        ${WZCR}
        ${WZQ}
        ${WZQD}
        ${WZQD2}
        )

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
        log-lib

        # Specifies the name of the NDK library that
        # you want CMake to locate.
        log)

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
        native-lib

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib} libopencv_java4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

然后，我们需要在Application中初始化native-lib

init {
    //System.loadLibrary("opencv_java4")
    System.loadLibrary("native-lib")
}
1
2
3
4

接着，我们需要初始化扫码模型

下载模型文件,并导入到res/raw目录下

然后在Application中进行初始化，将模型文件复制到内部存储中

MMKV.initialize(this)
GlobalScope.launch(Dispatchers.IO) {
    MMKV.defaultMMKV()?.encode(
        MMKVKey.WeChatQRCodeDetectProtoTxt,
        copyFromAssets(R.raw.detect_prototxt, "wechat_qrcode", "detect.prototxt")
    )
    MMKV.defaultMMKV()?.encode(
        MMKVKey.WeChatQRCodeDetectCaffeModel,
        copyFromAssets(R.raw.detect_caffemodel, "wechat_qrcode", "detect.caffemodel")
    )
    MMKV.defaultMMKV()?.encode(
        MMKVKey.WeChatQRCodeSrProtoTxt,
        copyFromAssets(R.raw.sr_prototxt, "wechat_qrcode", "sr.prototxt")
    )
    MMKV.defaultMMKV()?.encode(
        MMKVKey.WeChatQRCodeSrCaffeModel,
        copyFromAssets(R.raw.sr_caffemodel, "wechat_qrcode", "sr.caffemodel")
    )
}

fun Context.copyFromAssets(@RawRes resId: Int, targetDir:String, targetFileName:String): String {
    val targetDirFile = getDir(targetDir, Context.MODE_PRIVATE)
    val targetFile = File(targetDirFile, targetFileName)
    targetFile.outputStream().use {
        resources.openRawResource(resId).copyTo(it)
    }
    return targetFile.absolutePath
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在初始化WeChatQrCode的时候，将模型路径传入

mWeChatQRCode = WeChatQRCode(
    MMKV.defaultMMKV()?.decodeString(MMKVKey.WeChatQRCodeDetectProtoTxt) ?: "",
    MMKV.defaultMMKV()?.decodeString(MMKVKey.WeChatQRCodeDetectCaffeModel) ?: "",
    MMKV.defaultMMKV()?.decodeString(MMKVKey.WeChatQRCodeSrProtoTxt) ?: "",
    MMKV.defaultMMKV()?.decodeString(MMKVKey.WeChatQRCodeSrCaffeModel) ?: ""
)
1
2
3
4
5
6

然后，我们只需要将摄像头中的图像，传递给微信扫码库进行解析即可

override fun analyze(image: ImageProxy) {
    val rectangles = ArrayList<Mat>()
    //进行解析并识别，并获得解析结果results
    val results : List<String> = weChatQRCode.detectAndDecode(gray(image), rectangles)
    Toast.makeText(this, results.toString(), Toast.LENGTH_SHORT).show()
    image.close()
}

fun gray(image: ImageProxy): Mat {
    val planeProxy = image.planes
    val width = image.width
    val height = image.height
    val yPlane = planeProxy[0].buffer
    val yPlaneStep = planeProxy[0].rowStride
    return Mat(height, width, CvType.CV_8UC1, yPlane, yPlaneStep.toLong())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

最后，别忘了申请权限

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.CAMERA" />

ActivityCompat.requestPermissions(
        this,
        arrayOf(Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE),
        1
)
1
2
3
4
5
6
7
8
9

完工 !

附上源码地址 https://download.csdn.net/download/EthanCo/20618652

不过接入微信扫码库还是有一定门槛的，如果想要更快速的接入扫码库，可以使用华为的扫码库，某些扫码场景下，比微信扫码还要强 ! 详见我的另一篇博客 Android 接入华为扫码库，实现堪比微信扫码的效果

感谢
https://blog.csdn.net/qq_35054151/article/details/113488372
https://mp.weixin.qq.com/s/GBXkRuS_fPsxr0uT5tR0Sw