打印机蓝牙权限、搜索、连接功能

android/app/src/main/AndroidManifest.xml

@@ -54,7 +54,7 @@
 
 
     <application
-        android:name="${applicationName}"
+        android:name=".app.MyApplication"
         android:icon="@drawable/ic_launcher"
         android:label="${APP_NAME}"
         android:requestLegacyExternalStorage="true">

android/app/src/main/java/com/szls/lszlgl/MainActivity.java

@@ -20,6 +20,6 @@ public class MainActivity extends FlutterActivity {
         GeneratedPluginRegister.registerGeneratedPlugins(flutterEngine);
 
         //插件实例的注册,就是自己写个类，然后实现Flutter提供的FlutterPlugin接口
-        flutterEngine.getPlugins().add(new BluetoothPlugin());
+        flutterEngine.getPlugins().add(new BluetoothPlugin(this));
     }
 }

android/app/src/main/java/com/szls/lszlgl/app/MyApplication.java

@@ -0,0 +1,24 @@
+package com.szls.lszlgl.app;
+
+import android.app.Application;
+import android.content.Context;
+
+/**
+ * 自定义Application
+ *
+ * @author zhangbin
+ */
+public class MyApplication extends Application {
+    private static MyApplication instance;
+
+    @Override
+    public void onCreate() {
+
+        super.onCreate();
+        instance = this;
+    }
+
+    public static MyApplication getInstance() {
+        return instance;
+    }
+}

android/app/src/main/java/io/flutter/plugins/BluetoothPlugin.java

@@ -1,53 +1,123 @@
 package io.flutter.plugins;
 
 import android.Manifest;
+import android.annotation.SuppressLint;
 import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
 import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.location.LocationManager;
 import android.os.Build;
+import android.text.TextUtils;
 import android.util.Log;
 import android.view.View;
 import android.widget.Toast;
 
 import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+import androidx.fragment.app.FragmentActivity;
 
 import com.permissionx.guolindev.PermissionX;
+import com.szls.lszlgl.MainActivity;
 
 import java.security.Permission;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 import dev.fluttercommunity.plus.androidintent.IntentSender;
 import dev.fluttercommunity.plus.androidintent.MethodCallHandlerImpl;
 import io.flutter.embedding.engine.plugins.FlutterPlugin;
+import io.flutter.embedding.engine.plugins.activity.ActivityAware;
+import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding;
 import io.flutter.plugin.common.BinaryMessenger;
+import io.flutter.plugin.common.EventChannel;
 import io.flutter.plugin.common.MethodCall;
 import io.flutter.plugin.common.MethodChannel;
 
+import io.flutter.plugin.common.EventChannel.EventSink;
+import io.flutter.plugin.common.EventChannel.StreamHandler;
+import io.flutter.plugins.bean.BlueDeviceInfo;
+import io.flutter.plugins.utils.BluetoothUtils;
+import io.flutter.plugins.utils.PrintUtil;
+
 public class BluetoothPlugin implements FlutterPlugin, MethodChannel.MethodCallHandler {
 
     private String methodChannelName = "io.flutter.plugins/bluetooth";
     private MethodChannel methodChannel;
 
+    private ExecutorService executorService;
+
+    private static final String USER_DEFINED = "自定义";
+    private static final String delimiterStr = "_NIMBOT_";
+
+    private String printNameStart = "";
+
+    OnDiscoveryDeviceStreamHandler onDiscoveryDeviceStreamHandler;
+    private EventChannel onReceiveDeviceChannel;
+    public EventChannel.EventSink onReceiveSink;
+
+    private BlueDeviceInfo itemPosition;
+
+//    private MainActivity _mainActivity;
 
+
+    Context _applicationContext;
     private BluetoothAdapter mBluetoothAdapter;
 
-    public BluetoothPlugin() {
+
+    public BluetoothPlugin(MainActivity activity) {
         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+//        _mainActivity = activity;
+
+        //注册广播
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
+        intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
+        intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+        intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
+        intentFilter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
+        intentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
+        intentFilter.addAction(BluetoothDevice.ACTION_PAIRING_REQUEST);
+        Log.d("ble", "初始化:注册广播 ");
+        activity.registerReceiver(receiver, intentFilter);
+        Log.d("ble", "初始化: 注册完成");
+
+        //注册线程池
+        ThreadFactory threadFactory = runnable -> {
+            Thread thread = new Thread(runnable);
+            thread.setName("connect_activity_pool_%d");
+            return thread;
+        };
+        executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1024), threadFactory, new ThreadPoolExecutor.AbortPolicy());
+
 
     }
 
     @Override
     public void onAttachedToEngine(@NonNull FlutterPluginBinding flutterPluginBinding) {
         setupChannels(flutterPluginBinding.getBinaryMessenger(), flutterPluginBinding.getApplicationContext());
+
+
     }
 
     private void setupChannels(BinaryMessenger binaryMessenger, Context applicationContext) {
 
-        methodChannel = new MethodChannel(binaryMessenger, methodChannelName);
-        applicationContext = applicationContext.getApplicationContext();
-        applicationContext.
+        _applicationContext = applicationContext.getApplicationContext();
 
+        methodChannel = new MethodChannel(binaryMessenger, methodChannelName + "/methods");
         methodChannel.setMethodCallHandler(this);
 
+        onReceiveDeviceChannel = new EventChannel(binaryMessenger, methodChannelName + "/onDiscoveryDevice");
+        onDiscoveryDeviceStreamHandler = new OnDiscoveryDeviceStreamHandler();
+        onReceiveDeviceChannel.setStreamHandler(onDiscoveryDeviceStreamHandler);
     }
 
     @Override
@@ -59,14 +129,28 @@ public class BluetoothPlugin implements FlutterPlugin, MethodChannel.MethodCallH
     public void onMethodCall(@NonNull MethodCall methodCall, @NonNull MethodChannel.Result result) {
         switch (methodCall.method) {
 
-            case "isSupportBle":
+            case "isBleOpen":
                 Log.d("ble", "isSupportBle");
-                result.success(true);
+                result.success(mBluetoothAdapter.isEnabled());
+                break;
+            case "isSDKIntGreaterOrEqual":
+                Log.d("ble", "isSDKIntGreaterOrEqual");
+                result.success(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S);
                 break;
-            case "startScan":
-                Log.d("ble", "startScan");
-                startScan(result);
+            case "startBluetoothDiscovery":
+                Log.d("ble", "startBluetoothDiscovery");
+                startBluetoothDiscovery(result);
                 break;
+            case "startBluetoothPair":
+                Log.d("ble", "startBluetoothPair");
+                startBluetoothPair(methodCall, result);
+                break;
+            case "startBluetoothConnect":
+                Log.d("ble", "startBluetoothConnect :"+methodCall.arguments);
+                startBluetoothConnect(methodCall, result);
+                break;
+
+
             case "autoLogin":
 
                 break;
@@ -74,58 +158,211 @@ public class BluetoothPlugin implements FlutterPlugin, MethodChannel.MethodCallH
 
                 break;
             case "currentAccount":
-                 break;
+                break;
             case "logout":
-                 break;
+                break;
             case "markAllMessagesRead":
-                 break;
-            default:
-            {
+                break;
+            default: {
                 result.notImplemented();
                 break;
             }
         }
     }
 
-
     private void teardownChannels() {
         methodChannel.setMethodCallHandler(null);
         methodChannel = null;
+//        // 注销广播接收器
+//        if (mBluetoothAdapter != null && mBluetoothAdapter.isDiscovering()) {
+//            mBluetoothAdapter.cancelDiscovery();
+//        }
+//        requireActivity().unregisterReceiver(receiver);
     }
 
+    void startBluetoothDiscovery(@NonNull MethodChannel.Result result) {
+
+        if (ActivityCompat.checkSelfPermission(_applicationContext, Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
+
+            Log.d("ble", "checkSelfPermission false");
+            return;
+        }
+
+        if (mBluetoothAdapter.isDiscovering()) {
 
-    void startScan(@NonNull MethodChannel.Result result) {
+            if (mBluetoothAdapter.cancelDiscovery()) {
+                executorService.execute(() -> {
+                    try {
+                        //取消后等待1s后再次搜索
+                        Thread.sleep(1000);
+                        mBluetoothAdapter.startDiscovery();
+                        Log.d("ble", "测试:开始搜索7");
+                    } catch (InterruptedException e) {
+                        Log.d("ble", "测试:开始搜索8");
+                        e.printStackTrace();
+                    }
+                });
 
-        Log.d("ble", "开始搜索 ");
-        if (!mBluetoothAdapter.isEnabled()) {
-            result.success(1); //
+
+            }
         } else {
-            permissionRequest();
+            Log.d("ble", "测试:开始搜索9");
+            mBluetoothAdapter.startDiscovery();
+            Log.d("ble", "测试:开始搜索10");
         }
     }
 
-    private void permissionRequest() {
-        String[] permissions;
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            permissions = new String[]{Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT};
-        } else {
-            permissions = new String[]{Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION};
+    void startBluetoothPair(@NonNull MethodCall methodCall, @NonNull MethodChannel.Result result) {
+
+        if (ActivityCompat.checkSelfPermission(_applicationContext, Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
+            return;
+        }
+        if (mBluetoothAdapter.isDiscovering()) {
+            mBluetoothAdapter.cancelDiscovery();
         }
+        Log.d("ble", "startBluetoothPair");
+        String deviceMac = methodCall.arguments.toString();
+        String[] deviceInfoList = deviceMac.split(delimiterStr);
+        itemPosition = new BlueDeviceInfo(deviceInfoList[0], deviceInfoList[1], Integer.parseInt(deviceInfoList[2]));
+        BluetoothDevice bluetoothDevice = mBluetoothAdapter.getRemoteDevice(itemPosition.getDeviceHardwareAddress());
+
+        executorService.submit(() -> {
+//            requireActivity().runOnUiThread(() -> {
+//                bind.spinKit.setVisibility(View.GONE);
+//                fragment = new MyDialogLoadingFragment("配对中");
+//                fragment.show(requireActivity().getSupportFragmentManager(), "pairing");
+//            });
+            Log.d("ble", "配对: 开始");
+            boolean returnValue = false;
+            try {
+                returnValue = BluetoothUtils.createBond(bluetoothDevice);
+            } catch (Exception e) {
+                Log.d("ble", "闪退日志" + e.getMessage());
+            }
+            Log.d("ble", "配对: 进行中:" + returnValue);
+        });
+    }
 
+    void startBluetoothConnect(@NonNull MethodCall methodCall, @NonNull MethodChannel.Result result) {
 
+        if (ActivityCompat.checkSelfPermission(_applicationContext, Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
+            return;
+        }
+        if (mBluetoothAdapter.isDiscovering()) {
+            mBluetoothAdapter.cancelDiscovery();
+        }
 
-        PermissionX.init(requireActivity())
-                .permissions(permissions)
-                .request(this::handlePermissionResult);
+        String deviceInfo = methodCall.arguments.toString();
+        String[] deviceInfoList = deviceInfo.split(delimiterStr);
+        for(int i =0; i < deviceInfoList.length ; i++){
+            Log.d("ble", i+":"+deviceInfoList[i]);
+        }
+        Log.d("ble", "startBluetoothConnect : ---"+deviceInfo + "----0:"+deviceInfoList[0]);
+        itemPosition = new BlueDeviceInfo(deviceInfoList[0], deviceInfoList[1], Integer.parseInt(deviceInfoList[2]));
+        BluetoothDevice bluetoothDevice = mBluetoothAdapter.getRemoteDevice(itemPosition.getDeviceHardwareAddress());
+
+        executorService.submit(() -> {
+//            requireActivity().runOnUiThread(() -> {
+//                bind.spinKit.setVisibility(View.GONE);
+//                fragment = new MyDialogLoadingFragment("连接中");
+//                fragment.show(requireActivity().getSupportFragmentManager(), "CONNECT");
+//            });
+
+            BlueDeviceInfo blueDeviceInfo = new BlueDeviceInfo(bluetoothDevice.getName(), bluetoothDevice.getAddress(), itemPosition.getConnectState());
+            PrintUtil.setConnectedType(-1);
+            int connectResult = PrintUtil.connectBluetoothPrinter(blueDeviceInfo.getDeviceHardwareAddress());
+            Log.d("ble", "测试：连接结果 " + connectResult);
+            result.success(connectResult);
+
+        });
     }
 
-    private void handlePermissionResult(boolean allGranted, List<String> grantedList, List<String> deniedList) {
-        if (allGranted) {
-            Log.d("ble", "handleAllPermissionsGranted ");
-//            handleAllPermissionsGranted();
-        } else {
-            Log.d("ble", "权限打开失败 ");
+
+
+    private final BroadcastReceiver receiver = new BroadcastReceiver() {
+
+
+        @SuppressLint("MissingPermission")
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            //蓝牙发现
+            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
+                Log.v("ble", "测试:搜索中");
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+
+                if (device != null) {
+                    @SuppressLint("MissingPermission") String deviceName = device.getName();
+                    String deviceHardwareAddress = device.getAddress();
+                    @SuppressLint("MissingPermission") int deviceStatus = device.getBondState();
+
+
+                    @SuppressLint("MissingPermission") boolean supportBluetoothType = device.getType() == BluetoothDevice.DEVICE_TYPE_CLASSIC || device.getType() == BluetoothDevice.DEVICE_TYPE_DUAL;
+                    boolean supportPrintName;
+
+
+                    if (USER_DEFINED.equals(printNameStart)) {
+                        printNameStart = "";
+                    }
+
+                    if (TextUtils.isEmpty(printNameStart)) {
+                        supportPrintName = deviceName != null;
+                    } else {
+                        supportPrintName = deviceName != null && deviceName.startsWith(printNameStart);
+                    }
+
+                    if (supportBluetoothType && supportPrintName) {
+
+                        Log.d("ble", "测试:打印机名称- " + deviceName + "，设备地址:" + deviceHardwareAddress + "，设备类型:" + device.getType() + ", 设备状态："+deviceStatus);
+                        Log.d("ble", "sink:" + onReceiveSink + ":" + "onDiscoveryDeviceStreamHandler" +  (onDiscoveryDeviceStreamHandler != null) + "onDiscoveryDeviceStreamHandler.sink != null:" + (onDiscoveryDeviceStreamHandler.sink));
+                        if (onDiscoveryDeviceStreamHandler != null && onDiscoveryDeviceStreamHandler.sink != null) {
+                            onDiscoveryDeviceStreamHandler.sink.success(deviceName+delimiterStr+deviceHardwareAddress+delimiterStr+deviceStatus);
+                        }
+                    }
+
+                }
+
+            } else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {
+                Log.v("ble", "测试:开始搜索");
+//                bind.spinKit.setVisibility(View.VISIBLE);
+            } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
+                Log.v("ble", "测试:搜索结束");
+//                bind.spinKit.setVisibility(View.GONE);
+            } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
+                int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1);
+                Log.d("ble", "测试:配对状态改变:0 " + state);
+                if(itemPosition != null) {
+                    itemPosition.setConnectState(state);
+                    if (onDiscoveryDeviceStreamHandler != null && onDiscoveryDeviceStreamHandler.sink != null) {
+                        onDiscoveryDeviceStreamHandler.sink.success(itemPosition.getDeviceName()+delimiterStr+itemPosition.getDeviceHardwareAddress()+delimiterStr+itemPosition.getConnectState());
+                    }
+                }
+            } else if (BluetoothDevice.ACTION_PAIRING_REQUEST.equals(action)) {
+//                if (fragment != null) {
+//                    fragment.dismiss();
+//                }
+            }
         }
+    };
+
+
+}
+
+
+class OnDiscoveryDeviceStreamHandler implements EventChannel.StreamHandler {
+
+    public EventChannel.EventSink sink;
+
+    @Override
+    public void onListen(Object o, EventChannel.EventSink eventSink) {
+
+        Log.d("ble", "OnDiscoveryDeviceStreamHandler: onListen");
+        sink = eventSink;
     }
+    @Override
+    public void onCancel(Object o) {
 
+        Log.e("zhousuhua","OnReceiveDataStreamHandler=== onCancel");
+        sink = null;
+    }
 }

android/app/src/main/java/io/flutter/plugins/bean/BlueDeviceInfo.java

@@ -0,0 +1,58 @@
+package io.flutter.plugins.bean;
+
+import androidx.annotation.Nullable;
+
+public class BlueDeviceInfo {
+
+
+    String deviceName;
+    String deviceHardwareAddress;
+    int connectState;
+
+    public BlueDeviceInfo(String deviceName, String deviceHardwareAddress, int connectState) {
+        this.deviceName = deviceName;
+        this.deviceHardwareAddress = deviceHardwareAddress;
+        this.connectState = connectState;
+    }
+
+    public String getDeviceName() {
+        return deviceName;
+    }
+
+    public void setDeviceName(String deviceName) {
+        this.deviceName = deviceName;
+    }
+
+    public String getDeviceHardwareAddress() {
+        return deviceHardwareAddress;
+    }
+
+    public void setDeviceHardwareAddress(String deviceHardwareAddress) {
+        this.deviceHardwareAddress = deviceHardwareAddress;
+    }
+
+    public int getConnectState() {
+        return connectState;
+    }
+
+    public void setConnectState(int connectState) {
+        this.connectState = connectState;
+    }
+
+
+    @Override
+    public int hashCode() {
+        return deviceName.hashCode();
+    }
+
+    @Override
+    public boolean equals(@Nullable Object obj) {
+        BlueDeviceInfo blueDeviceInfo = (BlueDeviceInfo) obj;
+        if (blueDeviceInfo != null) {
+            return deviceName.equals(blueDeviceInfo.deviceName);
+        }
+
+        return false;
+
+    }
+}

android/app/src/main/java/io/flutter/plugins/utils/BluetoothUtils.java

@@ -0,0 +1,31 @@
+package io.flutter.plugins.utils;
+
+import android.bluetooth.BluetoothDevice;
+
+import java.lang.reflect.Method;
+
+/**
+ * 蓝牙工具类，用于处理蓝牙设备配对等操作。
+ * @author zhangbin
+ */
+public class BluetoothUtils {
+
+    /**
+     * 与设备配对
+     *
+     * @param btDevice 要配对的蓝牙设备
+     * @return 配对是否成功
+     * @throws Exception 反射调用可能引发异常
+     */
+    public static boolean createBond(BluetoothDevice btDevice) throws Exception {
+        // 获取 BluetoothDevice 类的类对象
+        Class<?> btClass = BluetoothDevice.class;
+
+        // 获取 createBond 方法的引用
+        Method createBondMethod = btClass.getMethod("createBond");
+        // 调用 createBond 方法，返回配对结果
+        return (Boolean) createBondMethod.invoke(btDevice);
+    }
+
+
+}

android/app/src/main/java/io/flutter/plugins/utils/PrintUtil.java

@@ -0,0 +1,214 @@
+package io.flutter.plugins.utils;
+
+
+import android.app.Application;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.gengcon.www.jcprintersdk.JCPrintApi;
+import com.gengcon.www.jcprintersdk.callback.Callback;
+import com.gengcon.www.jcprintersdk.callback.PrintCallback;
+import com.szls.lszlgl.app.MyApplication;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 打印工具类
+ *
+ * @author zhangbin
+ */
+public class PrintUtil {
+    private static final String TAG = "PrintUtil";
+    private static int mConnectedType = -1;
+    /**
+     * 单例实例，使用 volatile 保证多线程可见性和有序性
+     */
+    private static volatile JCPrintApi api;
+
+    /**
+     * 回调接口，用于处理打印机状态变化事件
+     */
+    private static final Callback CALLBACK = new Callback() {
+        private static final String TAG = "PrintUtil";
+
+        /**
+         * 连接成功回调
+         *
+         * @param address 设备地址，蓝牙为蓝牙 MAC 地址，WIFI 为 IP 地址
+         * @param type   连接类型，0 表示蓝牙连接，1 表示 WIFI 连接
+         */
+        @Override
+        public void onConnectSuccess(String address, int type) {
+            mConnectedType = type;
+        }
+
+        /**
+         * 断开连接回调
+         * 当设备断开连接时，将调用此方法。
+         */
+        @Override
+        public void onDisConnect() {
+            mConnectedType = -1;
+        }
+
+        /**
+         * 电量变化回调
+         * 当设备电量发生变化时，将调用此方法。
+         *
+         * @param powerLevel 电量等级，取值范围为 1 到 4，代表有 1 到 4 格电，满电是 4 格
+         */
+        @Override
+        public void onElectricityChange(int powerLevel) {
+
+        }
+
+        /**
+         * 监测上盖状态变化回调
+         * 当上盖状态发生变化时，将调用此方法。目前该回调仅支持 H10/D101/D110/D11/B21/B16/B32/Z401/B3S/B203/B1/B18 系列打印机。
+         *
+         * @param coverStatus 上盖状态，0 表示上盖打开，1 表示上盖关闭
+         */
+        @Override
+        public void onCoverStatus(int coverStatus) {
+
+        }
+
+        /**
+         * 监测纸张状态变化
+         * 当纸张状态发生变化时，将调用此方法。目前该回调仅支持H10/D101/D110/D11/B21/B16/B32/Z401/B203/B1/B18 系列打印机。
+         *
+         * @param paperStatus 0为不缺纸 1为缺纸
+         */
+        @Override
+        public void onPaperStatus(int paperStatus) {
+
+        }
+
+        /**
+         * 监测标签rfid读取状态变化
+         * 当标签rfid读取状态发生变化时，将调用此方法。
+         *
+         * @param rfidReadStatus 0为未读取到标签RFID 1为成功读取到标签RFID 目前该回调仅支持H10/D101/D110/D11/B21/B16/B32/Z401/B203/B1/B18 系列打印机。
+         */
+        @Override
+        public void onRfidReadStatus(int rfidReadStatus) {
+
+        }
+
+
+        /**
+         * 监测碳带rfid读取状态变化
+         * 当碳带rfid读取状态发生变化时，将调用此方法。
+         *
+         * @param ribbonRfidReadStatus 0为未读取到碳带RFID 1为成功读取到碳带RFID 目前该回调仅支持B18/B32/Z401/P1/P1S 系列打印机。
+         */
+        @Override
+        public void onRibbonRfidReadStatus(int ribbonRfidReadStatus) {
+
+        }
+
+        /**
+         * 监测碳带状态变化
+         * 当纸张状态发生变化时，将调用此方法
+         *
+         * @param ribbonStatus 0为无碳带 1为有碳带 目前该回调仅支持B18/B32/Z401/P1/P1S系列打印机。
+         */
+        @Override
+        public void onRibbonStatus(int ribbonStatus) {
+
+        }
+
+
+        /**
+         * 固件异常回调，需要升级
+         * 当设备连接成功但出现固件异常时，将调用此方法，表示需要进行固件升级。
+         */
+        @Override
+        public void onFirmErrors() {
+
+        }
+    };
+
+
+    /**
+     * 获取 JCPrintApi 单例实例
+     *
+     * @return JCPrintApi 实例
+     */
+    public static JCPrintApi getInstance() {
+        // 双重检查锁定以确保只初始化一次实例
+        if (api == null) {
+            synchronized (PrintUtil.class) {
+                if (api == null) {
+                    api = JCPrintApi.getInstance(CALLBACK);
+                    //api.init已废弃，使用initSdk替代，方法名含义更准确
+
+                    api.initSdk(MyApplication.getInstance());
+                    //获取内置目录路径
+                    File directory = MyApplication.getInstance().getFilesDir();
+                    //获取自定义字体路径
+                    File customFontDirectory = new File(directory, "custom_font");
+                    api.initDefaultImageLibrarySettings(customFontDirectory.getAbsolutePath(), "");
+
+                }
+            }
+        }
+
+        return api;
+
+    }
+
+
+    /**
+     * 通过打印机mac地址进行蓝牙连接开启打印机（同步）
+     *
+     * @param address 打印机地址
+     * @return 成功与否
+     */
+    public static int connectBluetoothPrinter(String address) {
+        // 获取单例实例以确保线程安全
+        JCPrintApi localApi = getInstance();
+        //api.openPrinterByAddress(address)，使用connectBluetoothPrinter替代，方法名含义更准确
+        return localApi.connectBluetoothPrinter(address);
+    }
+
+    /**
+     * 关闭打印机
+     */
+    public static void close() {
+        // 获取单例实例以确保线程安全
+        JCPrintApi localApi = getInstance();
+        localApi.close();
+    }
+
+
+    public static int getConnectedType() {
+        return mConnectedType;
+    }
+
+    public static void setConnectedType(int connectedType) {
+        mConnectedType = connectedType;
+    }
+
+    /**
+     * 检查打印机是否连接
+     *
+     * @return 连接状态代码
+     */
+    public static int isConnection() {
+        // 获取单例实例以确保线程安全
+        JCPrintApi localApi = getInstance();
+        return localApi.isConnection();
+    }
+
+
+}

lib/page/print/connect_print_page.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:lszlgl/base/base_lifecycle_state.dart';
+import 'package:lszlgl/service/print_service.dart';
 import 'package:signature/signature.dart';
 import 'package:lszlgl/widget/button.dart';
 
@@ -41,6 +42,8 @@ class _ConnectPrintPageState extends BaseLifecycleState<ConnectPrintPage> {
   final submitEnable = false.notifier<bool>();
 
   late List<ServiceModel> serviceList;
+  late List<BlueDeviceInfo> deviceList;
+  late List<String> deviceMacList;
 
   @override
   void initState() {
@@ -48,21 +51,27 @@ class _ConnectPrintPageState extends BaseLifecycleState<ConnectPrintPage> {
     serviceList = [
       ServiceModel(name: '搜索', icon: imgHomeListPzjc, onTap: () => startScan()),
     ];
+    deviceList = [];
+    deviceMacList = [];
   }
 
   /// 去连接
   Future<void> startScan() async {
 
-    int result = await BluetoothPlugin.instance.startScan();
-    if(result == 1) {
-      // 蓝牙未开启
-      MyNavigator.showToast('蓝牙未开启');
-    }
+    setState(() {
+      deviceList = [];
+      deviceMacList = [];
+    });
+    await PrintService.startBluetoothDiscovery();
   }
 
   /// 去打印
-  void startPrint() {
-
+  Future<void> startConnect(BlueDeviceInfo deviceInfo) async {
+    if(deviceInfo.connectStateStr == '未配对') {
+      await PrintService.startBluetoothPair(deviceInfo);
+    } else if(deviceInfo.connectStateStr == '已配对') {
+      await PrintService.startBluetoothConnect(deviceInfo);
+    }
   }
 
   @override
@@ -85,6 +94,22 @@ class _ConnectPrintPageState extends BaseLifecycleState<ConnectPrintPage> {
     } else {
       nextEnable.value = true;
     }
+
+    BluetoothPlugin.instance.onReceiveDataStream.listen((deviceInfo) {
+      if(deviceInfo != null) {
+        if(deviceMacList.contains(deviceInfo.deviceMac)) {
+          setState(() {
+            deviceMacList.removeWhere((element) => element == deviceInfo.deviceMac);
+            deviceList.removeWhere((element) => element.deviceMac == deviceInfo.deviceMac);
+          });
+        }
+        setState(() {
+          deviceMacList.add(deviceInfo.deviceMac);
+          deviceList.add(deviceInfo);
+        });
+      }
+    });
+
   }
 
   @override
@@ -109,6 +134,11 @@ class _ConnectPrintPageState extends BaseLifecycleState<ConnectPrintPage> {
             serviceList.length,
                 (index) => buildServiceItem(serviceList[index]),
           ).toList(),
+
+          ...List.generate(
+            deviceList.length,
+                (index) => buildDeviceItem(deviceList[index]),
+          ).toList(),
         ],
       ),
     );
@@ -157,4 +187,43 @@ class _ConnectPrintPageState extends BaseLifecycleState<ConnectPrintPage> {
       ),
     );
   }
+
+  Widget buildDeviceItem(BlueDeviceInfo deviceInfo) {
+    return GestureDetector(
+      onTap: () {
+        // 连接
+        startConnect(deviceInfo);
+      },
+      child: Container(
+        margin: const EdgeInsets.only(left: 12, right: 12, bottom: 22),
+        padding: const EdgeInsets.symmetric(vertical: 10),
+        clipBehavior: Clip.hardEdge,
+        decoration: BoxDecoration(
+          borderRadius: const BorderRadius.all(Radius.circular(12)),
+          boxShadow: [BoxShadow(color: Colors.black.withOpacity(0.1), offset: const Offset(0, 5), blurRadius: 4)],
+          image: const DecorationImage(image: AssetImage(imgHomeListBg), fit: BoxFit.fill),
+        ),
+        child: Row(
+          mainAxisAlignment: MainAxisAlignment.spaceAround,
+          children: [
+            Text(
+              deviceInfo.deviceName,
+              textAlign: TextAlign.center,
+              style: const TextStyle(color: Color(0xFF333333), fontSize: 15, fontWeight: FontWeight.w500),
+            ),
+            Text(
+              deviceInfo.deviceMac,
+              textAlign: TextAlign.center,
+              style: const TextStyle(color: Color(0xFF333333), fontSize: 15, fontWeight: FontWeight.w500),
+            ),
+            Text(
+              deviceInfo.connectStateStr,
+              textAlign: TextAlign.center,
+              style: const TextStyle(color: Color(0xFF333333), fontSize: 15, fontWeight: FontWeight.w500),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
 }

lib/page/print/print_page.dart

@@ -5,6 +5,7 @@ import 'package:lszlgl/page/print/connect_print_page.dart';
 import 'package:signature/signature.dart';
 import 'package:lszlgl/widget/button.dart';
 
+import '../../service/print_service.dart';
 import '../home/home_page.dart';
 
 class PrintPageArgs {
@@ -59,8 +60,8 @@ class _PrintPageState extends BaseLifecycleState<PrintPage> {
   }
 
   /// 去打印
-  void startPrint() {
-
+  Future<void> startPrint() async {
+    // await PrintService.startBluetoothPair(deviceInfo);
   }
 
   @override

lib/plugin/bluetooth_plugin.dart

@@ -1,6 +1,10 @@
 import 'dart:io';
 
 import 'package:flutter/services.dart';
+import 'package:logger/logger.dart';
+
+import '../main.dart';
+import '../router/my_navigator.dart';
 
 class BluetoothPlugin {
   factory BluetoothPlugin() => _instance;
@@ -8,28 +12,119 @@ class BluetoothPlugin {
   static final BluetoothPlugin _instance = BluetoothPlugin._();
   static BluetoothPlugin get instance => _instance;
 
-  final MethodChannel _channel = const MethodChannel("io.flutter.plugins/bluetooth");
+   final String delimiterStr = "_NIMBOT_";
+  final MethodChannel _channel = const MethodChannel("io.flutter.plugins/bluetooth/methods");
+  final EventChannel _onReceiveDataStream = const EventChannel('io.flutter.plugins/bluetooth/onDiscoveryDevice');
+
+
+  //是否打开蓝牙
+  Future<bool> isBleOpen() async {
+    if (Platform.isIOS) {
+      return true;
+    }
+    return _channel.invokeMethod('isBleOpen').then<bool>((d) => d);
+  }
+
+  //安卓版本是否大于等于31
+  Future<bool> isSDKIntGreaterOrEqual31() async {
+    if (Platform.isIOS) {
+      return true;
+    }
+    return _channel.invokeMethod('isSDKIntGreaterOrEqual').then<bool>((d) => d);
+  }
 
   //开始扫描
-  Future<int> startScan() async {
+  Future<int> startBluetoothDiscovery() async {
     if (Platform.isIOS) {
       return 0;
     }
-    return _channel.invokeMethod('startScan').then<int>((d) => d);
+    return _channel.invokeMethod('startBluetoothDiscovery').then<int>((d) => d);
   }
 
-  //设备是否支持蓝牙
-  Future<bool> isSupportBle() async {
+  //开始配对
+  Future<int> startBluetoothPair(BlueDeviceInfo deviceInfo) async {
     if (Platform.isIOS) {
-      return true;
+      return 0;
+    }
+    return _channel.invokeMethod('startBluetoothPair').then<int>((d) => d);
+  }
+
+  //开始连接
+  Future<int> startBluetoothConnect(BlueDeviceInfo deviceInfo) async {
+
+    if (Platform.isIOS) {
+      return 0;
     }
-    return _channel.invokeMethod('isSupportBle').then<bool>((d) => d);
+    String deviceInfoStr = deviceInfo.deviceName+delimiterStr+deviceInfo.deviceMac+delimiterStr+deviceInfo.connectState;
+    return _channel.invokeMethod('startBluetoothConnect', deviceInfoStr).then<int>((d) => d);
   }
 
-  //打开蓝牙
-  Future open() async {
-    if (Platform.isAndroid) {
-      _channel.invokeMethod('open');
+  //开始连接
+  Future<int> startBluetoothPrint(BlueDeviceInfo deviceInfo) async {
+
+    if (Platform.isIOS) {
+      return 0;
     }
+    String deviceInfoStr = deviceInfo.deviceName+delimiterStr+deviceInfo.deviceMac+delimiterStr+deviceInfo.connectState;
+    return _channel.invokeMethod('startBluetoothPrint', deviceInfoStr).then<int>((d) => d);
+  }
+
+
+
+
+  /// 接收数据监听
+  Stream<BlueDeviceInfo?> get onReceiveDataStream async* {
+
+    yield* _onReceiveDataStream
+        .receiveBroadcastStream()
+        .map((buffer) {
+
+      String str = buffer;
+      List<String> strList = str.split(delimiterStr);
+
+      if(strList.length == 3) {
+        BlueDeviceInfo deviceInfo = BlueDeviceInfo(deviceName: strList[0], deviceMac: strList[1], connectState: strList[2]);
+        return deviceInfo;
+      }
+      return null;
+    });
+  }
+
+
+}
+
+
+class BlueDeviceInfo {
+
+  String deviceName;
+  String deviceMac;
+  String connectState;
+
+  String? _connectStateStr;
+
+  BlueDeviceInfo({required this.deviceName, required this.deviceMac, required this.connectState});
+
+
+  String get connectStateStr {
+
+    if(_connectStateStr != null) {
+     return _connectStateStr!;
+    }
+
+    if(connectState == '10') {
+      _connectStateStr = "未配对";
+    }
+    if(connectState == '11') {
+      _connectStateStr = "配对中";
+    }
+    if(connectState == '12') {
+      _connectStateStr = "已配对";
+    }
+    return _connectStateStr ?? "未知";
+  }
+
+  @override
+  String toString() {
+    return {'deviceName:': deviceName, "mac:": deviceMac, "state:": connectState}.toString();
   }
 }

lib/service/print_service.dart

@@ -0,0 +1,107 @@
+
+
+import 'package:lszlgl/utils/permission_utils.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+import '../plugin/bluetooth_plugin.dart';
+import '../router/my_navigator.dart';
+
+class PrintService {
+  PrintService._();
+
+  //是否打开蓝牙
+  static Future<bool> isBleOpen() async {
+    return await BluetoothPlugin.instance.isBleOpen();
+  }
+
+  //安卓版本是否大于等于31
+  static Future<bool> isSDKIntGreaterOrEqual() async {
+    return await BluetoothPlugin.instance.isSDKIntGreaterOrEqual31();
+  }
+
+  //是否支持蓝牙操作
+  static Future<bool> canExecAction() async {
+    if (await isBleOpen()) {
+
+      bool allGranted = false;
+      String permissionName = '';
+      // permissionRequest
+     if(await isSDKIntGreaterOrEqual()) {
+
+       if (await PermissionHandler.handleWith(Permission.bluetoothScan)) {
+         allGranted = true;
+       } else {
+         permissionName = Permission.bluetoothScan.toString();
+         allGranted = false;
+       }
+       if(await PermissionHandler.handleWith(Permission.bluetoothConnect)) {
+         allGranted = true;
+       } else {
+         permissionName = '$permissionName ${Permission.bluetoothConnect}';
+         allGranted = false;
+       }
+     }
+      //所有权限申请通过
+      if (await PermissionHandler.handleWith(Permission.location)) {
+        allGranted = true;
+      } else {
+        permissionName = Permission.location.toString();
+        allGranted = false;
+      }
+     if(allGranted) {
+       return true;
+     } else {
+       MyNavigator.showToast('权限打开失败:$permissionName');
+       return false;
+     }
+    } else {
+      // 蓝牙未开启
+      MyNavigator.showToast('蓝牙未开启');
+      return false;
+    }
+  }
+
+  //开始扫描
+  static Future<int> startBluetoothDiscovery() async {
+
+    if(await canExecAction()) {
+      return await BluetoothPlugin.instance.startBluetoothDiscovery();
+    } else {
+      return 0;
+    }
+  }
+
+  //开始配对
+  static Future<int> startBluetoothPair(BlueDeviceInfo deviceInfo) async {
+
+    if(await canExecAction()) {
+      return await BluetoothPlugin.instance.startBluetoothPair(deviceInfo);
+    } else {
+      return 0;
+    }
+  }
+
+  //开始连接
+  static Future<int> startBluetoothConnect(BlueDeviceInfo deviceInfo) async {
+
+    if(await canExecAction()) {
+      return await BluetoothPlugin.instance.startBluetoothConnect(deviceInfo);
+    } else {
+      return 0;
+    }
+  }
+
+  //开始打印
+  static Future<int> startBluetoothPrint(BlueDeviceInfo deviceInfo) async {
+
+    if(await canExecAction()) {
+      return await BluetoothPlugin.instance.startBluetoothPrint(deviceInfo);
+    } else {
+      return 0;
+    }
+  }
+
+
+}
+
+

lib/utils/permission_utils.dart

@@ -0,0 +1,75 @@
+import 'package:flutter/material.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+import '../router/my_navigator.dart';
+
+
+class PermissionHandler {
+  static Future<bool> handleWith(Permission permission,
+      {bool showTip = true}) async {
+    if (await permission.request().isGranted ||
+        await permission.request().isLimited) {
+      return true;
+    }
+
+    if (await permission.isPermanentlyDenied ||
+        await permission.isRestricted ||
+        await permission.isDenied) {
+      if (showTip) {
+
+        MyNavigator.showDialog(
+          builder: (_) => PermissionAlertDialog(permission: permission),
+        );
+      }
+    }
+    return false;
+  }
+}
+
+class PermissionAlertDialog extends StatelessWidget {
+  final Permission permission;
+
+  const PermissionAlertDialog({Key? key, required this.permission}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    String content = '';
+    if (this.permission is PermissionWithService) {
+      if (this.permission == Permission.location) {
+        content = '请前往系统设置打开定位权限';
+      }
+    }
+
+    if (this.permission is Permission) {
+      if (this.permission == Permission.photos) {
+        content = '请前往系统设置打开相册权限';
+      } else if (this.permission == Permission.camera) {
+        content = '请前往系统设置打开相机权限';
+      } else if (this.permission == Permission.microphone) {
+        content = '请前往系统设置打开麦克风权限';
+      } else if (this.permission == Permission.storage) {
+        content = '请前往系统设置打开存储权限';
+      } else if (this.permission == Permission.bluetoothScan) {
+        content = '请前往系统设置打开蓝牙权限';
+      } else {
+        content = '请前往系统设置打开该权限';
+      }
+    }
+
+    return AlertDialog(
+      title: Text('提示'),
+      content: Text(content),
+      backgroundColor: Colors.white,
+      elevation: 24,
+      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+      actions: <Widget>[
+        TextButton(
+          child: Text('知道了'),
+          onPressed: () {
+            // XRouter.pop(context);
+          },
+        ),
+      ],
+    );
+  }
+}