uniapp—android原生插件开发（2原生插件开发）

本篇文章从实战角度出发，将UniApp集成新大陆PDA设备RFID的全过程分为四部曲，涵盖环境搭建、插件开发、AAR打包、项目引入和功能调试。通过这份教程，轻松应对安卓原生插件开发与打包需求！

***环境问题移步至：uniapp—android原生插件开发（1环境准备）

一、将App离线SDK解压，并导入Android Studio中

下载地址：Android 离线SDK - 正式版 | uni小程序SDK

***强烈建议：不要不听劝，本人踩了两天坑，不然有意想不到的问题等着你解决

下载最新版本Android 离线SDK - 正式版，不然会出现不兼容问题。
最好用案例中的gradle版本，不然会出现不兼容问题。
包名能共用一个就共用一个，不然难的去找问题。

解压App离线SDK、并将UniPlugin-Hello-AS项目导入Android Studio中

等待编译完成，需要较长的时间（15分钟左右，根据电脑性能、网速决定）

二、新建自定义模块（uniplugin_rfid）

***强烈建议：不要不听劝，本人踩了两天坑，不然有意想不到的问题等着你解决

把模块名定义好。
把事先定义好的包名直接拿过来用（事先生成的appKey中填写的包名，此处用之前定义好的包名），当然也可以重新定义新的包名，然后再去改appKey中的包名，再重新生成appKey即可。

新建模块，

定义模块名、定义包名，生成模块

中途可能会因为build.gradle编译报错，直接将uniplugin_module模块下的build.gradle覆盖刚生成模块下的build.gradle，然后点击Try Again或者Sync Now

覆盖AndroidManifest.xml文件，并修改配置，此处会报错，会提示你新建一个java类，直接创建，然后UniModule类（必须继承UniModule，必须@UniJSMethod注解），此时AndroidManifest.xml还会报错，按照提示修复即可变成同样的结构。

创建RfidModule类，如果上一步已创建则忽略此步骤

注意：必须继承UniModule，必须@UniJSMethod注解

添加测试方法：

package com.recognition.uniplugin_rfid;

import android.content.Context;
import android.util.Log;

import com.alibaba.fastjson.JSONObject;
import com.nlscan.uhf.lib.UHFReader;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import io.dcloud.feature.uniapp.annotation.UniJSMethod;
import io.dcloud.feature.uniapp.bridge.UniJSCallback;
import io.dcloud.feature.uniapp.common.UniModule;

public class RfidModule extends UniModule {

    // 使用UniJSMethod注解，才能使用js调用
    @UniJSMethod(uiThread = false)
    public void  add(JSONObject json, UniJSCallback callback) {
        final int a = json.getInteger("a");
        final int b = json.getInteger("b");
        callback.invoke(new JSONObject() {{
            put("code", 0);
            put("result", a + b);
        }});
    }


    private MyUhfManager uhfManager;

    // 初始化UHF设备
    @UniJSMethod(uiThread = false)
    public void initialize(Context context) {
        if (context != null) {
            uhfManager = uhfManager.getInstance(context.getApplicationContext());
        } else {
            Log.e("UHFPlugin", "Context is null, using application context instead.");
            uhfManager = uhfManager.getInstance(context.getApplicationContext());
        }
    }

    // 连接UHF设备
    @UniJSMethod(uiThread = false)
    public boolean connect() {
        if (uhfManager != null) {
            final CountDownLatch latch = new CountDownLatch(1);
            final boolean[] isConnected = {false};

            uhfManager.powerOn(result -> {
                isConnected[0] = result;
                latch.countDown(); // 回调完成时释放锁
            });

            try {
                // 等待回调完成（设定超时以防止无尽等待）
                latch.await(5, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            return isConnected[0];
        }
        return false;
    }

    // 断开连接
    @UniJSMethod(uiThread = false)
    public boolean disconnect() {
        if (uhfManager != null && uhfManager.isPowerOn()) {
            // 假设调用 stopInventory 后达到断开效果
            UHFReader.READER_STATE stopInventoryState = uhfManager.stopInventory();

            // 如果有设置功率的方法，也可以尝试将功率设为零来模拟断开
            uhfManager.setReadPower(0, result -> {
                // 此处 result 用于表示功率设为0是否成功
            });

            // 检查 stopInventory 的状态是否成功
            return stopInventoryState == UHFReader.READER_STATE.OK_ERR;
        }
        return false;
    }



    // 启动盘点
    @UniJSMethod(uiThread = false)
    public boolean startInventory() {
        if (uhfManager != null) {
            UHFReader.READER_STATE state = uhfManager.startInventory();
            return state == UHFReader.READER_STATE.OK_ERR;
        }
        return false;
    }

    // 停止盘点
    @UniJSMethod(uiThread = false)
    public boolean stopInventory() {
        if (uhfManager != null) {
            UHFReader.READER_STATE state = uhfManager.stopInventory();
            return state == UHFReader.READER_STATE.OK_ERR;
        }
        return false;
    }

    // 读取标签数据
    @UniJSMethod(uiThread = false)
    public String readTagData(int bank, int address, int blkcnt, String accessPassword) {
        if (uhfManager != null) {
            byte[] data = uhfManager.getDataByArea(bank, accessPassword, blkcnt);
            return data != null ? UHFReader.bytes_Hexstr(data) : null;
        }
        return null;
    }

    // 写入标签数据到EPC区
    @UniJSMethod(uiThread = false)
    public boolean writeTagDataToEPC(String data, String accessPassword) {
        if (uhfManager != null) {
            final CountDownLatch latch = new CountDownLatch(1);
            final boolean[] writeSuccess = {false};

            uhfManager.writeDataToEPC(data, accessPassword, (result, state) -> {
                writeSuccess[0] = result;  // 将回调结果存储到数组中
                latch.countDown();         // 回调完成时释放锁
            });

            try {
                // 等待回调完成（设置超时防止阻塞）
                latch.await(5, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            return writeSuccess[0];  // 返回写入操作的结果
        }
        return false;
    }

    // 写入标签数据到用户区
    @UniJSMethod(uiThread = false)
    public boolean writeTagDataToUser(String data, String accessPassword) {
        if (uhfManager != null) {
            final CountDownLatch latch = new CountDownLatch(1);
            final boolean[] writeSuccess = {false};

            uhfManager.writeDataToUser(data, accessPassword, (result, state) -> {
                writeSuccess[0] = result;  // 将回调结果存储到数组中
                latch.countDown();         // 回调完成时释放锁
            });

            try {
                // 等待回调完成（设置超时防止阻塞）
                latch.await(5, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            return writeSuccess[0];  // 返回写入操作的结果
        }
        return false;
    }

}