数据收发与通知回调

//BLE服务UUID
public final static UUID BLE_UUID_SERVICE = Config.INSTANCE.getBLE_SERVICE_UUID();
//BLE的写特征UUID
public final static UUID BLE_UUID_WRITE = Config.INSTANCE.getBLE_WRITE_UUID();
//BLE的通知特征UUID
public final static UUID BLE_UUID_NOTIFICATION = Config.INSTANCE.getBLE_NOTIFY_UUID();
//BLE的通知特征的描述符UUID
public final static UUID BLE_UUID_NOTIFICATION_DESCRIPTOR = UUID.fromString("00002902-0000-1000-8000-00805F9B34FB");

public boolean addSendTask(BluetoothGatt gatt, UUID serviceUUID, UUID characteristicUUID, byte[] data, OnWriteDataCallback callback) {
    if (null == mBleManager || null == gatt || null == serviceUUID || null == characteristicUUID || null == data || data.length == 0) {
        return false;
    }
    int mtu = mBleManager.getBleMtu();
    JL_Log.d(TAG, "addSendTask", "mtu : " + mtu);
    int dataLen = data.length;
    int blockCount = dataLen / mtu;
    boolean ret = false;
    for (int i = 0; i < blockCount; i++) {
        byte[] mBlockData = new byte[mtu];
        System.arraycopy(data, i * mtu, mBlockData, 0, mBlockData.length);
        ret = addSendData(gatt, serviceUUID, characteristicUUID, mBlockData, callback);
    }

    if (0 != dataLen % mtu) {
        byte[] noBlockData = new byte[dataLen % mtu];
        System.arraycopy(data, dataLen - dataLen % mtu, noBlockData, 0, noBlockData.length);
        ret = addSendData(gatt, serviceUUID, characteristicUUID, noBlockData, callback);
    }
    return ret;
}

private boolean addSendData(BluetoothGatt gatt, UUID serviceUUID, UUID characteristicUUID, byte[] data, OnWriteDataCallback callback) {
    boolean ret = false;
    if (isDataSend) {
        BleSendTask sendTask = new BleSendTask(gatt, serviceUUID, characteristicUUID, data, callback);
        try {
            mQueue.put(sendTask);
            ret = true;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (ret && isThreadWaiting && !isWaitingForCallback) {
            isThreadWaiting = false;
            synchronized (mQueue) {
                mQueue.notify();
            }
        }
    }
    return ret;
}

@Override
public void run() {
    JL_Log.d(TAG, "send ble data thread is started.");
    if (mListener != null) {
        mListener.onStart(getId(), getName());
    }
    if (mBleManager != null) {
        synchronized (mQueue) {
            while (isDataSend) {
                mCurrentTask = null;
                isThreadWaiting = false;
                isWaitingForCallback = false;
                if (mQueue.isEmpty()) {
                    isThreadWaiting = true;
                    JL_Log.d(TAG, "queue is empty, so waiting for data");
                    try {
                        mQueue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    mCurrentTask = mQueue.peek();
                    if (mCurrentTask != null) {
                        isWaitingForCallback = mBleManager.writeDataByBle(mCurrentTask.mGatt, mCurrentTask.getServiceUUID(),
                                mCurrentTask.getCharacteristicUUID(), mCurrentTask.getData());
                        if (isWaitingForCallback) {
                            try {
                                mQueue.wait(BleManager.SEND_DATA_MAX_TIMEOUT);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        } else {
                            mCurrentTask.setStatus(-1);
                        }
                        JL_Log.d(TAG, "data send ret :" + mCurrentTask.getStatus());
                        if (mCurrentTask.getStatus() != BluetoothGatt.GATT_SUCCESS) { //发送失败
                            retryNum++;
                            if (retryNum >= 3) { //重发次数超过限制
                                callbackResult(mCurrentTask, false);
                                mQueue.clear();
                            } else {
                                if (mCurrentTask.getStatus() != -1) {
                                    mCurrentTask.setStatus(-1);
                                    try {
                                        sleep(10);
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                }
                                continue;
                            }
                        } else { //发送成功
                            callbackResult(mCurrentTask, true);
                        }
                    }
                    retryNum = 0;
                    if (!mQueue.isEmpty()) mQueue.poll();
                }
            }
        }
        isWaitingForCallback = false;
        isThreadWaiting = false;
        mQueue.clear();
        if (mListener != null) {
            mListener.onEnd(getId(), getName());
        }
        JL_Log.d(TAG, "send ble data thread exit.");
    }
}

private void callbackResult(BleSendTask task, boolean result) {
    if (task != null && task.getCallback() != null) {
        if (task.getBleGatt() == null) return;
        task.getCallback().onBleResult(task.getBleGatt().getDevice(), task.getServiceUUID(),
                task.getCharacteristicUUID(), result, task.getData());
    } else {
        JL_Log.i(TAG, "getCallback is null.");
    }
}

public abstract class BleEventCallback implements IBleEventCallback {

    @Override
    public void onAdapterChange(boolean bEnabled) { }

    @Override
    public void onDiscoveryState(boolean bStart) { }

    @Override
    public void onDiscoveryDevice(ScanDeviceInfo bleScanMessage) { }

    @Override
    public void onDiscoveryFail(int code, String message) { }

    @Override
    public void onBleConnection(BluetoothDevice device, int status) { }

    @Override
    public void onBleServiceDiscovery(BluetoothDevice device, int status, List<BluetoothGattService> services) { }

    @Override
    public void onBleNotificationStatus(BluetoothDevice device, UUID serviceUuid, UUID characteristicUuid, int status) { }

    @Override
    public void onBleDataBlockChanged(BluetoothDevice device, int block, int status) { }

    @Override
    public void onBleDataNotification(BluetoothDevice device, UUID serviceUuid, UUID characteristicsUuid, byte[] data) { }

    @Override
    public void onBleWriteStatus(BluetoothDevice device, UUID serviceUuid, UUID characteristicsUuid, byte[] data, int status) { }

    @Override
    public void onConnectionUpdated(BluetoothDevice device, int interval, int latency, int timeout, int status) { }
}

public class BleEventCallbackManager extends BleEventCallback  {
    private final ArrayList<BleEventCallback> mCallbacks = new ArrayList<>();
    private final Handler mHandler = new Handler(Looper.getMainLooper());

    public void registerBleEventCallback(BleEventCallback callback) {
        if (callback != null && !mCallbacks.contains(callback)) {
            mCallbacks.add(callback);
        }
    }

    public void unregisterBleEventCallback(BleEventCallback callback) {
        if (callback != null && !mCallbacks.isEmpty()) {
            mCallbacks.remove(callback);
        }
    }

    public void release() {
        mCallbacks.clear();
        mHandler.removeCallbacksAndMessages(null);
    }
    ...
}

private void callbackBleEvent(BleEventCallbackImpl impl) {
    if (null == impl) return;
    OnBleEventRunnable runnable = new OnBleEventRunnable(impl);
    if (Thread.currentThread().getId() == Looper.getMainLooper().getThread().getId()) {
        runnable.run();
    } else {
        mHandler.post(runnable);
    }
}

private class OnBleEventRunnable implements Runnable {
    private final BleEventCallbackImpl mImpl;

    public OnBleEventRunnable(BleEventCallbackImpl impl) {
        mImpl = impl;
    }

    @Override
    public void run() {
        if (!mCallbacks.isEmpty() && mImpl != null) {
            for (BleEventCallback callback : new ArrayList<>(mCallbacks)) {
                if (callback != null) {
                    mImpl.onCallback(callback);
                }
            }
        }
    }
}

private final BleEventCallback mBleEventCallback = new BleEventCallback() {
    @Override
    public void onBleConnection(BluetoothDevice device, int status) {
        // 连接状态变化：BluetoothProfile.STATE_CONNECTED / STATE_DISCONNECTED
    }

    @Override
    public void onBleDataNotification(BluetoothDevice device, UUID serviceUuid,
                                      UUID characteristicsUuid, byte[] data) {
        // 设备上报的数据到达，解析并刷新 UI
        String hex = CHexConver.bytesToHexString(data); // 十六进制展示
    }
};

@Override
protected void onStart() {
    super.onStart();
    BleManager.getInstance().registerBleEventCallback(mBleEventCallback);
}

@Override
protected void onStop() {
    super.onStop();
    BleManager.getInstance().unregisterBleEventCallback(mBleEventCallback);
}

byte[] payload = CHexConver.hexStringToBytes("01 02 03 ..."); // 完整业务数据包
BleManager.getInstance().sendDataToDevice(
        gatt, BleManager.BLE_UUID_SERVICE, BleManager.BLE_UUID_WRITE, payload,
        new OnWriteDataCallback() {
            @Override
            public void onBleResult(BluetoothDevice device, UUID serviceUuid,
                                    UUID characteristicUuid, boolean result, byte[] data) {
                if (result) {
                    // 该分块发送成功
                } else {
                    // 该分块重试 3 次后仍失败（或超时）
                }
            }
        });

SendBleDataThread thread = new SendBleDataThread(mBleManager, new OnThreadStateListener() {
    @Override
    public void onStart(long threadId, String threadName) {
        // 线程启动：禁用发送按钮
    }

    @Override
    public void onEnd(long threadId, String threadName) {
        // 线程退出：恢复 UI 状态
    }
});
thread.start();   // 启动后进入等待任务状态（isDataSend = true）

void onBleResult(BluetoothDevice device, UUID serviceUuid,
                 UUID characteristicUuid, boolean result, byte[] data);