Android-OBD开发

发表于 分类于 本文字数： 17k
Android与车载OBD设备的连接、通信

OBD设备

  在此之前，从未接触OBD这个东西，蓝牙也少有接触，谨以此篇来记录一下与OBD设备通信的开发过程

申请权限

  首先在清单文件中添加蓝牙权限

1
2
3
4
<!-- 使用蓝牙 -->
<uses-permission android:name="android.permission.BLUETOOTH" />
<!-- 蓝牙管理 -->
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

打开蓝牙

  创建一个OBDManager类，添加一个getInstance()方法，使用单例模式获取当前类的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class OBDManager {
    private static OBDManager obdManager;

    /**
     * 禁止创建对象
     */
    private OBDManager() {}

    /**
     * 通过单例模式获取该类的实例
     */
    public static OBDManager getInstance() {
        if (obdManager == null) {
            obdManager = new OBDManager();
        }
        return obdManager;
    }
}

  添加一个init()方法，为该类提供简单的初始化

1
2
3
4
5
6
7
8
9
10
11
12
private BluetoothAdapter bluetoothAdapter;  // 蓝牙适配器

/**
 * 初始化
 */
public void init() {
    // 初始化蓝牙适配器
    bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    // 还有另外一种获取蓝牙适配器的方法，不过比较麻烦
    //BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
    //bluetoothAdapter = bluetoothManager.getAdapter();
}

  判断设备是否拥有蓝牙功能，Android模拟器是提供不了蓝牙功能的

1
2
3
4
5
6
/**
 * 判断设备是否拥有蓝牙功能
 */
public boolean isHasBluetooth(Context context) {
    return (bluetoothAdapter != null && context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH));
}

  判断当前是否已经打开蓝牙，打开\关闭蓝牙

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
/**
 * 判断当前是否已经打开蓝牙
 */
public boolean isEnableBluetooth() {
    return bluetoothAdapter.isEnabled();
}

/**
 * 打开蓝牙，不需要手动操作
 */
public boolean enableBluetooth() {
    return bluetoothAdapter.enable();
}

/**
 * 打开蓝牙，需要手动确定
 */
public void enableBluetooth(Activity activity) {
    Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    activity.startActivityForResult(intent, 1);
}

/**
 * 关闭蓝牙，不需要手动操作
 */
public boolean disableBluetooth() {
    return bluetoothAdapter.disable();
}

扫描蓝牙

  在真正开始搜索蓝牙设备之前，需要先注册一个广播，在广播中接收系统搜索到的蓝牙设备，并统一添加到一个集合中，然后添加一个回调事件，用以再扫描到设备时调用

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
/**
 * 注册接收蓝牙搜索结果的广播
 */
public void register(Context context) {
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(BluetoothDevice.ACTION_FOUND);               // 接受搜索到蓝牙设备的广播
    intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);  // 接受配对状态改变时的广播
    context.registerReceiver(bluetoothReceiver, intentFilter);
}

/**
 * 注销接收蓝牙搜索结果的广播
 */
public void unregister(Context context) {
    context.unregisterReceiver(bluetoothReceiver);
}

// 储存搜索到的附近的蓝牙设备
private final List<BluetoothDevice> bluetoothDeviceList = new ArrayList<>();

/**
 * 获取搜索到的蓝牙设备
 */
public List<BluetoothDevice> getBluetoothDeviceList() {
    return bluetoothDeviceList;
}

/**
 * 清空已经搜索到的所有蓝牙设备
 */
public void clearBluetoothDeviceList() {
    bluetoothDeviceList.clear();
}

/**
 * 接收蓝牙搜索结果的广播，配对结果的广播
 */
private final BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (action != null) {
            if (action.equals(BluetoothDevice.ACTION_FOUND)) {
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                // 如果搜索到的设备不存在于集合中，那么添加到集合，屏蔽没有名称或者地址的蓝牙设备
                if (device.getName() != null && device.getAddress() != null && !isExistDevice(device)) {
                    bluetoothDeviceList.add(device);
                    // 扫描到设备时的回调
                    if (onScanBluetoothDeviceListener != null) {
                        onScanBluetoothDeviceListener.OnScan(device);
                    }
                }
            } else if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
                // 当前配对状态
                int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,BluetoothDevice.ERROR);
                // 上个配对状态
                int prevState = intent.getIntExtra(BluetoothDevice.EXTRA_PREVIOUS_BOND_STATE,BluetoothDeviceERROR);
                // 刚刚正在配对，现在配对成功，说明配对成功
                if (state == BluetoothDevice.BOND_BONDED && prevState == BluetoothDevice.BOND_BONDING) {
                    // 配对成功
                }
                // 刚刚没有配对，现在正在配对，说明开始配对
                else if (state == BluetoothDevice.BOND_BONDING && prevState == BluetoothDevice.BOND_NONE) {
                    // 开始配对
                }
                // 这个直接就说明配对失败
                else if (state == BluetoothDevice.BOND_NONE) {
                    // 配对失败
                }
            }
        }
    }

    /**
     * 如果集合中是否存在这个目标设备
     * @param newDevice 目标设备
     * @return 是否存在
     */
    private boolean isExistDevice(BluetoothDevice newDevice) {
        for (BluetoothDevice bluetoothDevice : bluetoothDeviceList) {
            if (bluetoothDevice.getAddress().equals(newDevice.getAddress())) {
                return true;
            }
        }
        return false;
    }
};

// 扫描到设备时的回调
private OnScanBluetoothDeviceListener onScanBluetoothDeviceListener;

// 扫描到设备时的回调
public interface OnScanBluetoothDeviceListener{
    void OnScan(BluetoothDevice bluetoothDevice);
}

  开始搜索蓝牙设备，停止搜索蓝牙设备，在开始搜索蓝牙设备的方法中传入回调方法，用以在搜索到蓝牙设备时调用

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
/**
 * 开始搜索附近蓝牙设备
 */
public synchronized void startScanBluetoothDevices(OnScanBluetoothDeviceListener onScanBluetoothDeviceListener) {
    // 如果蓝牙没启用，则启用蓝牙
    if (!isEnableBluetooth()) {
        enableBluetooth();
    }

    this.onScanBluetoothDeviceListener = onScanBluetoothDeviceListener;

    // 开始搜索附近设备
    bluetoothAdapter.startDiscovery();
}

/**
 * 停止搜索附近蓝牙设备
 */
public void cancelScanBluetoothDevices() {
    // 如果蓝牙没有启动，就不用继续向下执行了
    if (!isEnableBluetooth()) {
        return;
    }
    
    bluetoothAdapter.cancelDiscovery();
}

配对蓝牙

  调用setPin()方法使系统自动输入配对码，免去用户手动输入的繁琐，调用setPairingConfirmation()方法设置是否确认当前的配对，免去用户手动点击确认配对，调用createBond()即开始进行蓝牙配对

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
/**
 * 发送配对请求，进行蓝牙配对
 * @param bluetoothDevice 目标设备
 * @return 配对请求发送结果
 */
public boolean createBond(BluetoothDevice bluetoothDevice) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        return bluetoothDevice.createBond();
    } else {
        try {
            Method method = bluetoothDevice.getClass().getMethod("createBond");
            return (boolean) method.invoke(bluetoothDevice);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return false;
}

/**
 * 设置为确认配对状态，可以不经过用户操作自动配对蓝牙设备，这个权限无法授权给三方应用
 * @param bluetoothDevice 目标设备
 * @param confirm 是否为确认状态
 */
public boolean setPairingConfirmation(BluetoothDevice bluetoothDevice, boolean confirm) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        return bluetoothDevice.setPairingConfirmation(confirm);
    } else {
        try {
            Method method = bluetoothDevice.getClass().getMethod("setPairingConfirmation", boolean.class);
            return (boolean) method.invoke(bluetoothDevice, confirm);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return false;
}

/*
 * 设置配对码
 * @param bluetoothDevice 目标设备
 * @param pin 配对码
 */
public boolean setPin(BluetoothDevice bluetoothDevice, byte[] pin) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        return bluetoothDevice.setPin(pin);
    } else {
        try {
            Method method = bluetoothDevice.getClass().getMethod("setPin", byte[].class);
            return (boolean)method.invoke(bluetoothDevice, new Object[]{pin});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return false;
}

  然后写一个bondDevice()方法来调用这三个方法，注意调用顺序：setPin()、setPairingConfirmation()、createBond()，这里需要注意的是，我所开发的软件是一个拥有所有权限的系统软件，所以可以不经过用户操作自动配对蓝牙设备，正常的三方软件开发过程中，setPairingConfirmation()会发生异常，在删除该方法的调用后，系统会显示一个允许配对的对话框

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
/**
 * 配对蓝牙设备
 * @param bluetoothDevice 目标蓝牙设备
 * @param pinCode 配对所使用的pin码
 */
public void bondDevice(BluetoothDevice bluetoothDevice, String pinCode) {
    // 配对码不为空时设置配对码
    if (!TextUtils.isEmpty(pinCode)) {
        setPin(bluetoothDevice, pinCode.getBytes());// 设置pin码
    }
    setPairingConfirmation(bluetoothDevice, true);  // 设置为确认配对状态
    boolean bond = createBond(bluetoothDevice);     // 进行配对
    if (bond) {
        // 配对请求发送成功
    } else {
        // 配对请求发送失败
    }
}


/**
 * 目标蓝牙设备是否已经配对
 * @param bluetoothDevice 目标设备
 */
public boolean isBondDevice(BluetoothDevice bluetoothDevice) {
    return bluetoothDevice.getBondState() == BluetoothDevice.BOND_BONDED;
}

连接蓝牙

  经典蓝牙的连接相当于在两个设备之间建立了socket连接，是个耗时操作，所以需要在子线程中执行

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
/**
 * 经典蓝牙的连接相当于socket连接，是个耗时操作
 */
private class ConnectThread extends Thread {

    private final BluetoothSocket bluetoothSocket;

    public ConnectThread(BluetoothSocket socket) {
        bluetoothSocket = socket;
    }

    @Override
    public void run() {
        super.run();
        // 进行蓝牙socket连接时先取消搜索蓝牙设备
        cancelScanBluetoothDevices();
        try {
            // 建立蓝牙socket连接
            bluetoothSocket.connect();
        } catch (IOException e) {
            e.printStackTrace();
            // 连接失败，关闭socket连接
            closeConnect();
        }
    }

    /**
     * 关闭socket连接
     */
    public void closeConnect() {
        if (bluetoothSocket != null) {
            try {
                bluetoothSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

  使用一个connectToDevice()方法连接设备，传入的bluetoothDevice所代表的设备一定要已经成功配对，注意这里用到的UUID，它是一个预定的建立与OBD之间的连接所需的UUID，另外注意我们要使用createRfcommSocketToServiceRecord将本机作为一个客户端建立与OBD之间的连接，因为OBD是一种蓝牙设备，是一个服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// OBD通常默认会使用这个UUID
private final UUID uuid_obd = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
private ConnectThread connectThread;    // 建立Socket连接的进程

/**
 * 连接到蓝牙设备
 * @param bluetoothDevice 目标设备
 */
public synchronized void connectToDevice(BluetoothDevice bluetoothDevice) {
    try {
        // 创建与蓝牙设备之间通信的socket通道
        BluetoothSocket socket = bluetoothDevice.createRfcommSocketToServiceRecord(uuid_obd);
        // 关闭上个连接进程
        if (connectThread != null) {
            connectThread.closeConnect();
            connectThread = null;
        }
        // 开启一个socket连接进程，建立与蓝牙设备之间的socket连接
        connectThread = new ConnectThread(socket);
        connectThread.start();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

蓝牙通信

  创建一个MessageThread类，在这个类中完成两个蓝牙设备之间的通信

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

private MessageThread messageThread;    // 接收\发送消息的进程
private String message;                 // 蓝牙设备发送来的消息

/**
 * 该线程负责两个蓝牙设备之间的通信
 */
private class MessageThread extends Thread {

    private final InputStream inputStream;      // 接收消息
    private final OutputStream outputStream;    // 发送消息
    private boolean isReceiveMsg = false;       // 是否持续接收消息

    public MessageThread (BluetoothSocket socket) {
        InputStream _input = null;
        OutputStream _output = null;

        try {
            _input = socket.getInputStream();
            _output = socket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }

        inputStream = _input;
        outputStream = _output;
    }

    @Override
    public void run() {
        super.run();
        byte[] buffer = new byte[1024]; // 用于缓存数据的缓冲区
        int numBytes;                   // 缓冲区中的字节数
        isReceiveMsg = true;            // 开始接收消息

        // 循环读取数据
        while (isReceiveMsg) {
            try {
                numBytes = inputStream.read(buffer);
                if (numBytes > 0) {
                    message = new String(buffer, 0, numBytes);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭消息通道
     */
    public void closeMessage() {
        // 不再接收消息
        isReceiveMsg = false;
        // 中断该线程
        this.interrupt();

        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (outputStream != null) {
            try {
                outputStream.flush();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 发送消息给蓝牙设备
     * @param bytes 消息字节流
     */
    public void write(byte[] bytes) {
        try {
            outputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

  在添加直接写入和读取消息的方法，方便外部调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 获取蓝牙设备发送的消息
 */
public String getMessage() {
    String _message = message;
    message = null;
    return _message;
}

/**
 * 向蓝牙设备发送消息
 */
public void sendMessage(String msg) {
    sendMessage(msg.getBytes());
}

/**
 * 向蓝牙设备发送消息
 */
public void sendMessage(byte[] bytes) {
    if (messageThread != null) {
        messageThread.write(bytes);
    }
}

  这样的话，在上面的建立蓝牙连接之后，就可以通过创建MessageThread对象来开启发送和接收消息，如下

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
/**
 * 经典蓝牙的连接相当于socket连接，是个耗时操作
 */
private class ConnectThread extends Thread {

    private final BluetoothSocket bluetoothSocket;

    public ConnectThread(BluetoothSocket socket) {
        bluetoothSocket = socket;
    }

    @Override
    public void run() {
        super.run();
        // 连接前先取消搜索蓝牙设备
        cancelScanBluetoothDevices();
        try {
            // 建立连接
            bluetoothSocket.connect();
            // 建立通信连接
            messageThread = new MessageThread(bluetoothSocket);
            messageThread.start();
        } catch (IOException e) {
            e.printStackTrace();
            // 连接失败，关闭连接
            closeConnect();
        }
    }

    /**
     * 关闭socket连接
     */
    public void closeConnect() {
        if (bluetoothSocket != null) {
            try {
                bluetoothSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (messageThread != null) {
            messageThread.closeMessage();
            messageThread = null;
        }
    }
}

其他方法

  其他经常用到的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 获取所有已经配对的蓝牙设备的列表
 */
public List<BluetoothDevice> getBluetoothBondList() {
    Set<BluetoothDevice> bondedDevices = bluetoothAdapter.getBondedDevices();
    return new ArrayList<>(bondedDevices);
}

/**
 * 通过MAC地址获取一个蓝牙设备
 * @param address MAC地址
 * @return 蓝牙设备
 */
public BluetoothDevice getDeviceByAddress(String address) {
    return bluetoothAdapter.getRemoteDevice(address);
}

  添加一个over()方法，用来结束一切

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * 结束所有
 */
public void over(Context context) {
    // 停止扫描设备
    cancelScanBluetoothDevices();
    // 注销通知
    unregister(context);
    // 清除已经扫描到的所有设备
    clearBluetoothDeviceList();
    // 清除扫描回调方法
    if (onScanBluetoothDeviceListener != null) {
        onScanBluetoothDeviceListener = null;
    }
    // 结束socket连接和通信
    if (connectThread != null) {
        connectThread.closeConnect();
        connectThread = null;
    }
}

使用方式

  在onCreate()方法中，先注册接收蓝牙的通知

1
OBDManager.getInstance().register(this);

  在onResume()方法中，使用initBlue()方法初始化蓝牙

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
/**
 * 初始化蓝牙
 */
private void initBlue() {
    OBDManager obdManager = OBDManager.getInstance();

    // 判断设备是否支持蓝牙功能
    boolean hasBluetooth = obdManager.isHasBluetooth(this);
    if (hasBluetooth) {
        // 判断蓝牙是否启用
        boolean isEnableBluetooth = obdManager.isEnableBluetooth();
        if (isEnableBluetooth) {
            // 蓝牙已启用，初始化蓝牙列表
            initList();
            // 开始搜索蓝牙设备
            obdManager.startScanBluetoothDevices(bluetoothDevice -> {
                // 搜索到蓝牙设备之后的回调
                initList();
            });
        } else {    // 如果蓝牙未启用，则在此启用蓝牙，并使用handle在启用一秒后递归
            // 正在启用蓝牙
            boolean enableBluetooth = obdManager.enableBluetooth();
            // 启用成功后等待一秒递归
            if (enableBluetooth) {
                // 此处是lambda表达式
                handler.postDelayed(this::initBlue, 1000);
            } else {
                // 蓝牙启用失败
            }
        }
    } else {
        // 设备不支持蓝牙功能
    }
}

  initBlue()中调用了initList()使搜索到的附近蓝牙设备在列表中显示，点击列表item时判断这个item所代表的蓝牙设备是否配对，如果已经配对则建立通信连接，如果没有配对则显示一个输入配对码的弹窗，输入配对码后点击确定进行配对，这里注意一下，OBD设备的配对码一般是“1234”或者“0000”

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
private RecyclerView blue_list = findViewById(R.id.blue_list); // 蓝牙列表
private BlueAdapter blueAdapter;    // RecyclerView适配器
private DialogX dialogX;            // 弹窗工具

/**
 * 初始化蓝牙列表
 */
private void initList() {
    OBDManager obdManager = OBDManager.getInstance();

    if (blueAdapter != null) {
        blueAdapter.setData(obdManager.getBluetoothDeviceList());
    } else {
        blueAdapter = new BlueAdapter(this, obdManager.getBluetoothDeviceList());
        LinearLayoutManager layoutManager = new LinearLayoutManager(this, RecyclerView.VERTICAL, false);
        blue_list.setAdapter(blueAdapter);
        blue_list.setLayoutManager(layoutManager);

        // 这里是自建的RecyclerView的itemClick
        blueAdapter.setOnRecyclerItemClick((position, bluetoothDevice) -> {
            // 如果已经配对
            if (obdManager.isBondDevice(bluetoothDevice)) {
                // 连接蓝牙设备
                obdManager.connectToDevice(bluetoothDevice);
            } else {
                // 显示一个带有编辑框和两个按钮的输入框
                dialogX = DialogXUtil.showEditTwoButtonDialog(this, "请输入配对码", "",
                        "配对码", "确定", "取消", InputType.TYPE_CLASS_TEXT, true,
                        new DialogXUtil.OnEditDialogOnSureButtonClick() {   // 点击确定按钮的事件
                            @Override
                            public void ClickListener(EditText dialog_edit) {
                                dialogX.dismiss();
                                String string = dialog_edit.getText().toString();
                                // 配对设备
                                obdManager.bondDevice(bluetoothDevice, string);
                            }
                        }, new DialogXUtil.OnEditDialogOnCancelButtonClick() {  // 点击取消按钮的事件
                            @Override
                            public void ClickListener(EditText dialog_edit) {
                                dialogX.dismiss();
                            }
                        });
            }
        });
    }
}

  再添加几个按钮，调用其他方法

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
// 打开蓝牙
open_blue.setOnClickListener(view -> {
    boolean enableBluetooth = OBDManager.getInstance().enableBluetooth();
    if (enableBluetooth) {
        TickApplication.getInstance().speak("蓝牙启用成功");
    } else {
        TickApplication.getInstance().speak("蓝牙启用失败");
    }
});

// 关闭蓝牙
close_blue.setOnClickListener(view -> {
    boolean disableBluetooth = OBDManager.getInstance().disableBluetooth();
    if (disableBluetooth) {
        TickApplication.getInstance().speak("蓝牙关闭成功");
    } else {
        TickApplication.getInstance().speak("蓝牙关闭失败");
    }
});

// 刷新蓝牙列表
notify_blue.setOnClickListener(view -> {
    OBDManager obdManager = OBDManager.getInstance();
    // 结束
    obdManager.over(this);
    // 注册通知
    obdManager.register(this);
    // 重新初始化
    initBlue();
});

  最后，在onDestory()方法中调用OBDManager类下的over()方法结束一切

1
OBDManager.getInstance().over(this);

效果预览

  列表中第三个那一堆东西是我在验证某个蓝牙设备已经匹配之后，显示它的所有UUID，打开设置是跳转到系统设置，缺点是没有在界面中添加通信功能，代码里都有