2 开发说明

2.1 使用流程

杰理之家SDK使用流程

2.2 蓝牙代理模块

Note

此模块只使用于 内置蓝牙代理实现
JL_BluetoothManager 是蓝牙接口管理, 3.1   蓝牙处理接口
BluetoothOperationImpl 是蓝牙功能具体实现, 3.1.1   蓝牙操作接口

2.2.1 扫描蓝牙设备

2.2.1.1 开始扫描设备

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
//蓝牙事件监听器
final BTEventCallback btEventCallback = new BTEventCallback() {
    @Override
    public void onDiscoveryStatus(boolean bBle, boolean bStart) {
        //回调发现设备状态
    }

    @Override
    public void onDiscovery(BluetoothDevice device, BleScanMessage bleScanMessage) {
        //回调发现的设备
    }
};
//注册蓝牙事件监听器
btManager.addEventListener(btEventCallback);
int scanType = BluetoothConstant.SCAN_TYPE_BLE; //扫描设备类型 --- BLE设备
// BluetoothConstant.SCAN_TYPE_CLASSIC --- 经典蓝牙设备
int timeout = 30 * 1000; //搜索超时 --- 30秒
//执行扫描设备
btManager.scan(scanType, timeout);
//注销蓝牙事件监听器
//        btManager.removeEventListener(btEventCallback);

Important

扫描蓝牙设备，需要确保 蓝牙 已开启
扫描蓝牙设备，需要确保 权限
1. Android 6.0+, 蓝牙权限 和 位置权限
2. Android 12.0+, 蓝牙搜索权限
扫描蓝牙设备，需要确保 位置服务 已启用
扫描蓝牙设备配置，参考 1.2.1 BluetoothOption

2.2.1.2 停止扫描设备

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
//执行停止扫描设备
btManager.stopScan();

2.2.2 连接设备

Important

连接设备操作，需要确保 蓝牙 已打开
连接设备操作，需要确保 权限 已授予
- Android 6.0+, 需要 蓝牙权限 和 位置权限
- Android 12.0+, 需要 蓝牙连接权限
连接设备操作，不允许并发执行，必须线性进行。
连接设备操作，是指连接通讯协议(BLE/SPP), 不包括经典蓝牙服务。

2.2.2.1 连接设备的通讯方式

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
if (btManager.getBluetoothOperation().isConnecting()) return; //正在连接设备
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//蓝牙事件监听器
final BTEventCallback btEventCallback = new BTEventCallback() {
    @Override
    public void onConnection(BluetoothDevice device, int status) {
        //回调蓝牙连接状态
    }
};
//注册蓝牙事件监听器
btManager.addEventListener(btEventCallback);
//执行连接设备
btManager.connect(device);
//执行断开设备
//        btManager.disconnect(device);
//注销蓝牙事件监听器
//        btManager.removeEventListener(btEventCallback);

2.2.2.2 连接设备的BLE

新版本

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
if (btManager.getBluetoothOperation().isConnecting()) return; //正在连接设备
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//蓝牙事件监听器
final BTEventCallback btEventCallback = new BTEventCallback() {
    @Override
    public void onConnection(BluetoothDevice device, int status) {
        //回调蓝牙连接状态
    }
};
//注册蓝牙事件监听器
btManager.addEventListener(btEventCallback);
//执行连接设备的BLE
btManager.connect(device, BluetoothConstant.PROTOCOL_TYPE_BLE);
//执行断开BLE
//        btManager.disconnect(device);
//注销蓝牙事件监听器
//        btManager.removeEventListener(btEventCallback);

Note

SDK_V4.0.0以后支持

旧版本

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//获取蓝牙功能实现对象
final IBluetoothOperation btOp = btManager.getBluetoothOperation();
//蓝牙事件回调
final BluetoothCallbackImpl bluetoothCallback = new BluetoothCallbackImpl() {
    @Override
    public void onBleConnection(BluetoothDevice device, int status) {
        //回调BLE设备连接成功
    }
};
//注册蓝牙事件回调
btOp.registerBluetoothCallback(bluetoothCallback);
//执行连接BLE操作
//result --- 操作结果
int result = btOp.connectBLEDevice(device);
//执行断开BLE
//        btOp.disconnectBLEDevice(device);
//注销蓝牙事件回调
//        btOp.unregisterBluetoothCallback(bluetoothCallback);

2.2.2.3 连接设备的SPP

新版本

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//蓝牙事件监听器
final BTEventCallback btEventCallback = new BTEventCallback() {
    @Override
    public void onConnection(BluetoothDevice device, int status) {
        //回调蓝牙连接状态
    }
};
//注册蓝牙事件监听器
btManager.addEventListener(btEventCallback);
//执行连接设备的SPP
btManager.connect(device, BluetoothConstant.PROTOCOL_TYPE_SPP);
//执行断开SPP
//        btManager.disconnect(device);
//注销蓝牙事件监听器
//        btManager.removeEventListener(btEventCallback);

Note

SDK_V4.0.0以后支持

旧版本

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//获取蓝牙功能实现对象
final IBluetoothOperation btOp = btManager.getBluetoothOperation();
//蓝牙事件回调
final BluetoothCallbackImpl bluetoothCallback = new BluetoothCallbackImpl() {
    @Override
    public void onSppStatus(BluetoothDevice device, int status) {
        //回调SPP设备连接成功
    }
};
//注册蓝牙事件回调
btOp.registerBluetoothCallback(bluetoothCallback);
//执行连接SPP操作
//result --- 操作结果
int result = btOp.connectSPPDevice(device);
//执行断开SPP
//        btOp.disconnectSPPDevice(device);
//注销蓝牙事件回调
//        btOp.unregisterBluetoothCallback(bluetoothCallback);

2.2.2.4 连接设备的经典蓝牙服务

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//蓝牙事件监听器
final BTEventCallback btEventCallback = new BTEventCallback() {
    @Override
    public void onA2dpStatus(BluetoothDevice device, int status) {
        //回调A2DP连接状态
    }

    @Override
    public void onHfpStatus(BluetoothDevice device, int status) {
        //回调HFP连接状态
    }
};
//注册蓝牙事件监听器
btManager.addEventListener(btEventCallback);
//执行连接经典蓝牙设备
btManager.startConnectByBreProfiles(device);
//执行断开经典蓝牙
//        btManager.disconnectByProfiles(device);
//注销蓝牙事件监听器
//        btManager.removeEventListener(btEventCallback);

2.2.3 数据读写

2.2.3.1 接收数据

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
//获取蓝牙功能实现对象
final IBluetoothOperation btOp = btManager.getBluetoothOperation();
//蓝牙事件回调
final BluetoothCallbackImpl bluetoothCallback = new BluetoothCallbackImpl() {
    @Override
    public void onBleDataNotification(BluetoothDevice device, UUID serviceUuid, UUID characteristicsUuid, byte[] data) {
        //回调接收到的BLE数据
    }

    @Override
    public void onSppDataNotification(BluetoothDevice device, byte[] data) {
        //回调接收到的SPP数据
    }
};
//注册蓝牙事件回调
btOp.registerBluetoothCallback(bluetoothCallback);
//注销蓝牙事件回调
//        btOp.unregisterBluetoothCallback(bluetoothCallback);

2.2.3.2 发送数据

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
final BluetoothDevice device = BluetoothUtil.getRemoteDevice("目标设备地址");
if (null == device) return;
//data  --- 发送数据
byte[] data = new byte[0];
//执行发数操作
//ret --- 操作结果
boolean ret = btManager.sendDataToDevice(device, data);

2.2.4 历史记录管理

2.2.4.1 获取历史记录列表

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
//获取历史记录列表
final List<HistoryBluetoothDevice> historyDevices = btManager.getHistoryBluetoothDeviceList();

2.2.4.2 回连历史记录

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
HistoryBluetoothDevice history = null; //历史记录， 不能为空
int timeout = 45 * 1000; //回连超时
//执行回连历史记录操作
btManager.reconnectHistoryBluetoothDevice(history, timeout, new OnReconnectHistoryRecordListener() {
    @Override
    public void onSuccess(HistoryBluetoothDevice history) {
        //回调回连历史记录成功
    }

    @Override
    public void onFailed(HistoryBluetoothDevice history, BaseError error) {
        //回调回连历史记录失败
        //history --- 历史记录
        //error   --- 错误信息
     }
});

Note

历史记录, HistoryBluetoothDevice

HistoryBluetoothDevice

历史记录

public class HistoryBluetoothDevice implements Parcelable {
    private String name;                //蓝牙设备名称
    /**
     * 通讯方式类型
     * <p>
     * {@link com.jieli.bluetooth.constant.BluetoothConstant#PROTOCOL_TYPE_BLE} --- BLE方式<br/>
     * {@link com.jieli.bluetooth.constant.BluetoothConstant#PROTOCOL_TYPE_SPP} --- SPP方式
     * </p>
     */
    private int type;
    private String address;             //蓝牙设备的地址
    private int chipType;               //芯片类型
    private int vid;                    //厂商ID
    private int uid;                    //客户ID
    private int pid;                    //产品ID
    //left device gps(默认是左侧设备，也默认左侧设备是主机)
    private double leftDevLatitude;     //左耳纬度
    private double leftDevLongitude;    //左耳经度
    private long leftDevUpdateTime;     //左耳GPS更新时间
    //right device gps
    private double rightDevLatitude;    //右耳纬度
    private double rightDevLongitude;   //右耳经度
    private long rightDevUpdateTime;    //右耳GPS更新时间
}

2.2.4.3 删除历史记录

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
HistoryBluetoothDevice history = null; //历史记录， 不能为空
//执行删除历史记录操作
btManager.removeHistoryDevice(history, new IActionCallback<HistoryBluetoothDevice>() {
    @Override
    public void onSuccess(HistoryBluetoothDevice message) {
        //回调删除历史记录成功
    }

    @Override
    public void onError(BaseError error) {
        //回调删除历史记录失败
        //error   --- 错误信息
    }
});

Note

历史记录, HistoryBluetoothDevice

2.2.4.4 清除所有历史记录

//获取蓝牙操作对象
final JL_BluetoothManager btManager = RCSPController.getInstance().getBluetoothManager();
if (null == btManager) return; //自定义蓝牙实现，btManager为空
//执行清除所有历史记录操作
btManager.clearHistoryDeviceRecord();
//注意，清除完成后，需要重新更新历史记录列表
final List<HistoryBluetoothDevice> historyDevices = btManager.getHistoryBluetoothDeviceList();

2.3 功能模块

2.3.1 术语

2.3.1.1 LTV格式

LTV 格式 = Length(1Byte) + Type(1Byte) + Value(n Bytes)

Length	Type	Value
1 Byte	1 Byte	n Bytes
长度	类型	内容
N	1	N - 1

字段解析 * Length : 数据长度。从 Type ~ Value 的长度，即(n + 1) * Type : 功能属性。 * Value : 数据内容。有效数据长度为 (Length - 1)

2.3.1.2 属性模型

对应类名: AttrBean

长度(Bytes)	名称	备注
1	size	属性长度(不包含当前Byte的长度)
1	attr type	属性类型(3.5 功能码)
size - 1	data	属性内容

2.3.2 通用命令处理示例

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造功能命令 - 比如, 获取设备信息
//mask = 0xffffffff;  -- 获取所有属性
CommandBase getDeviceInfoCmd = CommandBuilder.buildGetDeviceInfoCmd(mask);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), getDeviceInfoCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        //Step4: 判断是否有回复数据
        //注意 - 如果是没有回复数据的命令，回复数据为null
        boolean isHasResponse = cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE
                || cmd.getType() == CommandBase.FLAG_NO_PARAMETER_AND_RESPONSE;
        if (isHasResponse) {
            //Step5: 获取对应的命令数据
            GetTargetInfoCmd command = (GetTargetInfoCmd) cmd;
            //Step6: 获取回复数据
            TargetInfoResponse response = command.getResponse();
            if (null == response) { //回复数据为空，证明设备回复的数据有问题，进行异常处理
                onErrCode(device, new BaseError(ErrorCode.SUB_ERR_DATA_FORMAT, "Response data is error."));
                return;
            }
            //处理设备回复数据
        }
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.3 接收命令处理示例

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 添加蓝牙RCSP事件回调器
manager.addEventListener(new BTRcspEventCallback() {
    //回调设备发送的命令
    @Override
    public void onDeviceCommand(BluetoothDevice device, CommandBase cmd) {
        super.onDeviceCommand(device, cmd);
        //Step2: 处理命令
        if (cmd.getId() != Command.CMD_ADV_DEV_REQUEST_OPERATION) {
            //过滤命令
            return;
        }
        //Step3: 判断是否需要回复命令
        //需要回复的命令，处理完后需要回复结果
        //不需要回复的命令，处理完就完成了
        boolean isHasResponse = cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE
                || cmd.getType() == CommandBase.FLAG_NO_PARAMETER_AND_RESPONSE;
        //只处理目标命令 - 请求操作
        RequestAdvOpCmd requestAdvOpCmd = (RequestAdvOpCmd) cmd;
        //Step4: 获取参数
        RequestAdvOpParam param = requestAdvOpCmd.getParam();
        if (null == param) return; //异常处理
        //Step5: 处理数据
        switch (param.getOp()) {
            case Constants.ADV_REQUEST_OP_UPDATE_CONFIGURE: //更新配置
                break;
            case Constants.ADV_REQUEST_OP_SYNC_TIME: //同步时间
                break;
        }
        //Step6. 回复结果
        if (isHasResponse) {
            //组装结果
            requestAdvOpCmd.setStatus(StateCode.STATUS_SUCCESS);
            //组装参数
            requestAdvOpCmd.setParam(null);
            //发送回复命令
            manager.sendCommandResponse(device, requestAdvOpCmd);
        }
    }
});

2.3.4 发送数据包处理示例

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造功能命令 - 比如, 构建命令包
DataParam param = new DataParam(data);   //设置数据
param.setXmOpCode(responseOpId);         //设置响应命令号
CommandBase dataCmd = new DataCmd(param);
//默认数据包没有回复, 如果需要数据包有回复
//       dataCmd = new DataHasResponseCmd(param);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), dataCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        //Step4: 判断是否有回复数据
        //注意 - 如果是没有回复数据的命令，回复数据为null
        boolean isHasResponse = cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE
                || cmd.getType() == CommandBase.FLAG_NO_PARAMETER_AND_RESPONSE;
        if (isHasResponse) {
            //Step5: 获取对应的命令数据
            DataHasResponseCmd dataCmd = (DataHasResponseCmd) cmd;
            //Step6: 获取回复数据
            CommonResponse response = dataCmd.getResponse();
            if (null == response) { //回复数据为空，证明设备回复的数据有问题，进行异常处理
                onErrCode(device, new BaseError(ErrorCode.SUB_ERR_DATA_FORMAT, "Response data is error."));
                return;
            }
            //处理设备回复数据
            int responseOpID = dataCmd.getParam().getXmOpCode();
            byte[] data = response.getRawData();
            //parseData(data);
        }
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.5 基础功能

功能描述	命令原型	命令模型	命令参数	命令回复	备注
获取设备信息	Command.CMD_GET_TARGET_INFO	GetTargetInfoCmd	GetTargetInfoParam	TargetInfoResponse or DeviceInfo	参考 2.3.2 通用命令处理示例
查询设备系统信息	Command.CMD_GET_SYS_INFO	GetSysInfoCmd	GetSysInfoParam	SysInfoResponse	参考 2.3.2 通用命令处理示例
设置设备系统属性	Command.CMD_SET_SYS_INFO	SetSysInfoCmd	SetSysInfoParam	CommonResponse	参考 2.3.2 通用命令处理示例
监听设备系统属性变化	Command.CMD_SYS_INFO_AUTO_UPDATE	UpdateSysInfoCmd	SysInfoResponse	NULL	参考 2.3.3 接收命令处理示例
设置功能	Command.CMD_FUNCTION	FunctionCmd	FunctionParam	CommonResponse	参考 2.3.2 通用命令处理示例
重启设备	Command.CMD_REBOOT_DEVICE	RebootDeviceCmd	RebootDeviceParam	RebootDeviceResponse	参考 2.3.2 通用命令处理示例

Important

1. 表格中的数据模型都可以通过SDK查看

2. 本文档只展示部分重要数据模型

2.3.5.1 请求设备信息

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造功能命令 - 比如, 获取设备信息
//mask = 0xffffffff;  -- 获取所有属性
CommandBase getDeviceInfoCmd = CommandBuilder.buildGetDeviceInfoCmd(mask);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), getDeviceInfoCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        //Step4: 判断是否有回复数据
        //注意 - 如果是没有回复数据的命令，回复数据为null
        boolean isHasResponse = cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE
                || cmd.getType() == CommandBase.FLAG_NO_PARAMETER_AND_RESPONSE;
        if (isHasResponse) {
            //Step5: 获取对应的命令数据
            GetTargetInfoCmd command = (GetTargetInfoCmd) cmd;
            //Step6: 获取回复数据
            TargetInfoResponse response = command.getResponse();
            if (null == response) { //回复数据为空，证明设备回复的数据有问题，进行异常处理
                onErrCode(device, new BaseError(ErrorCode.SUB_ERR_DATA_FORMAT, "Response data is error."));
                return;
            }
            //处理设备回复数据
        }
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行请求设备功能并等待结果回调
controller.requestDeviceInfo(controller.getUsingDevice(), 0xffffffff, new OnRcspActionCallback<DeviceInfo>() {
    @Override
    public void onSuccess(BluetoothDevice device, DeviceInfo message) {
        //成功回调
        //message - 设备信息
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});
//第二种方式，获取缓存的设备信息
DeviceInfo deviceInfo = controller.getDeviceInfo();

GetTargetInfoParam

获取设备信息参数

public class GetTargetInfoParam extends BaseParameter {
    private int mask;//配置信息查询掩码
    private byte platform;//手机平台 0 : android 1: iOS  2 : web app
}

Note

mask需要参考 3.5 功能码

DeviceInfo

设备信息

public class DeviceInfo extends TargetInfoResponse {

    /*=============================================*
     * 闹钟信息
     *=============================================*/
    //闹钟信息
    private AlarmListInfo alarmListInfo;
    //闹钟响铃信息
    private List<DefaultAlarmBell> alarmDefaultBells;
    //闹钟数据结构版本
    private int alarmVersion;
    //闹钟拓展字段支持标识
    private byte alarmExpandFlag = 0x00;

    /*=============================================*
     * 音乐播放信息
     *=============================================*/
    //音乐名称
    private MusicNameInfo musicNameInfo;
    //音乐状态
    private MusicStatusInfo musicStatusInfo;
    //音乐播放模式信息
    private PlayModeInfo playModeInfo;
    //Aux播放状态
    private boolean isAuxPlay;
    //可以播放的格式
    private String playFileFormat;
    //当前播放的文件簇号
    private int cluster;
    //当前播放文件的设备序号
    private byte currentDevIndex;

    /*=============================================*
     * 均衡器信息
     *=============================================*/
    private EqPresetInfo eqPresetInfo;
    private EqInfo eqInfo;

    /*=============================================*
     * 设备存储器信息
     *=============================================*/
    private DevStorageInfo devStorageInfo;

    /*=============================================*
     * 灯光控制信息
     *=============================================*/
    private LightControlInfo lightControlInfo;

    /*=============================================*
     * 声卡信息
     *=============================================*/
    private EqInfo soundCardEqInfo;

    /*=============================================*
     * FM/FM_TX信息
     *=============================================*/
    private List<ChannelInfo> channelInfos; //频道列表
    private FmStatusInfo fmStatusInfo; //频道状态
    private float frequency; //发射频点

    /*=============================================*
     * ID3信息
     *=============================================*/
    private ID3MusicInfo iD3MusicInfo;

    /*=============================================*
     * 噪声处理(ANC)信息
     *=============================================*/
    private VoiceMode currentVoiceMode; //当前噪声处理模式信息
    private List<VoiceMode> voiceModeList; //所有噪声处理模式信息
    private AdaptiveData adaptiveData;     //自适应ANC数据
    private SmartNoPick smartNoPick;       //智能免摘信息
    /*降噪模式开启有效*/
    private SceneDenoising sceneDenoising; //场景降噪
    /*降噪模式开启有效*/
    private WindNoiseDetection windNoiseDetection; //风噪检测
    /*通透模式开启有效*/
    private VocalBooster vocalBooster;   //人声增强模式

    /*=============================================*
     * 通话信息
     *=============================================*/
    private int phoneStatus; //通话状态

    /*=============================================*
     * 拓展功能信息
     *=============================================*/
    private ExpandFunction expandFunction;

   /*=============================================*
    * 设备双连信息
    *=============================================*/
   private DoubleConnectionState doubleConnectionState;
   private ConnectedBtInfo connectedBtInfo;

    ...
}

TargetInfoResponse

目标设备信息

public class TargetInfoResponse extends CommonResponse {

    private String versionName; //设备版本名称
    private int versionCode;    // 设备版本信息
    private String protocolVersion;//协议版本

    //经典蓝牙相关信息
    private String edrAddr;//经典蓝牙地址
    private int edrStatus = 0;//经典蓝牙的连接状态
    private int edrProfile = 0;//经典蓝牙支持的协议

    //BLE相关信息
    private String bleAddr; //BLE地址

    //ai平台相关参数
    private int platform = -1;//AI平台类型（0：图灵；1：deepbrain；2：小米）
    private String license;//设备唯一标示

    //SysInfo属性
    private int volume;// 设备音量
    private int maxVol;
    private int quantity;   // 设备电量
    private int functionMask;// 功能支持掩码
    private byte curFunction = 0;// 当前模式
    private int sdkType; //是否为标准sdk 默认false即默认为ai sdk

    @Deprecated
    private String name;    //名字
    private int pid;        // 产品ID
    private int vid;        // 厂商ID
    private int uid;        // 客户ID
    private int mandatoryUpgradeFlag; //强制升级
    private int requestOtaFlag; //请求升级标志
    private int ubootVersionCode; //uboot 版本号
    private String ubootVersionName;  //uboot 版本名称
    private boolean isSupportDoubleBackup; //是否支持双备份升级（单备份[false]，需要断开回连过程；双备份[true]，不需要断开回连过程）
    private boolean isNeedBootLoader; //是否需要下载boot loader
    private int singleBackupOtaWay; //单备份OTA连接方式(00 -- 不使能 01 -- BLE  02 -- SPP)
    //拓展模式
    // 0：不启用
    // 1: 升级资源模式
    private int expandMode;

    private int allowConnectFlag; //是否允许连接 0 -- 允许 1 -- 不允许

    //用于服务器校验产品信息
    private String authKey; //认证秘钥
    private String projectCode; //项目标识码

    //用于自定义版本信息
    private String customVersionMsg;

    private boolean bleOnly; //是否仅仅连接ble设备，

    private boolean emitterSupport;//是否支持外设模式
    private int emitterStatus;//0x00:普通模式  0x01:外设模式

    private boolean isSupportMD5; //是否支持MD5读取
    private boolean isGameMode; //是否游戏模式
    private boolean isSupportSearchDevice; //是否支持查找设备

    private boolean supportOfflineShow = false;//是否支持usb、sd、linein不在线时显示功能图标
    private boolean supportUsb = true; //是否支持usb
    private boolean supportSd0 = true;//是否支持sd0
    private boolean supportSd1 = true;//是否支持sd1
    private boolean hideNetRadio = false;// 是否隐藏网络电台
    private boolean supportVolumeSync = false;//是否支持音量同步
    private boolean supportSoundCard = false;//是否支持声卡功能
    private boolean supportExternalFlashTransfer = false; //是否支持外挂Flash传输功能
    private boolean supportAnc = false; //是否支持主动降噪功能
    private boolean supportHearingAssist = false;// 是否⽀持辅听设置功能

    private boolean supportAdaptiveANC = false;  //是否支持自适应ANC算法

    private boolean supportSmartNoPick = false;  //是否支持智能免摘功能
    private boolean supportSceneDenoising = false; //是否支持场景降噪功能
    private boolean supportWindNoiseDetection = false; //是否支持风噪检测
    private boolean supportVocalBooster = false;  //是否支持人声增强

    private boolean supportDoubleConnection = false; //是否支持设备双连

    private boolean banEq;//禁止app调节设备eq

}

2.3.5.2 查询设备系统信息

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造查询设备系统信息命令
//功能码
int function = AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC; //公共属性
//查询当前设备模式和设备存储信息
int mask = 0x01 << AttrAndFunCode.SYS_INFO_ATTR_CUR_MODE_TYPE | 0x01 << AttrAndFunCode.SYS_INFO_ATTR_MUSIC_DEV_STATUS;
CommandBase getSysInfoCmd = CommandBuilder.buildGetSysInfoCmd((byte)function, mask);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), getSysInfoCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        //Step4: 判断是否有回复数据
        //注意 - 如果是没有回复数据的命令，回复数据为null
        boolean isHasResponse = cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE
                || cmd.getType() == CommandBase.FLAG_NO_PARAMETER_AND_RESPONSE;
        if (isHasResponse) {
            //Step5: 获取对应的命令数据
            GetSysInfoCmd command = (GetSysInfoCmd) cmd;
            //Step6: 获取回复数据
            SysInfoResponse response = command.getResponse();
            if (null == response) { //回复数据为空，证明设备回复的数据有问题，进行异常处理
                onErrCode(device, new BaseError(ErrorCode.SUB_ERR_DATA_FORMAT, "Response data is error."));
                return;
            }
            //处理设备回复数据
            //response.getFunction(); //功能码
            //response.getAttrs();    //功能属性
        }
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onDevStorageInfoChange(BluetoothDevice device, DevStorageInfo storageInfo) {
        //此处将会回调设备存储信息
    }

    @Override
    public void onDeviceModeChange(BluetoothDevice device, int mode) {
        //此处将会回调设备模式
    }
});
int func = AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC; //公共属性
//查询当前设备模式和设备存储信息
int mask = 0x01 << AttrAndFunCode.SYS_INFO_ATTR_CUR_MODE_TYPE | 0x01 << AttrAndFunCode.SYS_INFO_ATTR_MUSIC_DEV_STATUS;
//执行查询设备系统信息并等待结果回调
controller.getDevSysInfo(controller.getUsingDevice(), func, mask, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onDeviceModeChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Warning

function 需要参考 3.5   功能码
mask 需要参考 3.5   功能码
不允许mask为全F

GetSysInfoParam

获取系统信息参数

public class GetSysInfoParam extends BaseParameter {
    private byte function; //功能码
    private int mask; //功能掩码
}

2.3.5.3 设置设备系统属性

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造设置设备系统属性命令
//功能码
int function = AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC; //公共属性
//数据列表
AttrBean attrBean = new AttrBean();
attrBean.setType(AttrAndFunCode.SYS_INFO_ATTR_VOLUME);  //系统音量
attrBean.setAttrData(new byte[]{(byte) 0x0E}); //14等级
List<AttrBean> data = new ArrayList<>();
data.add(attrBean);
CommandBase setSysInfoCmd = CommandBuilder.buildSetSysInfoCmd((byte) function, data);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), setSysInfoCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        //等待系统调整成功后，通过更新设备系统信息命令通知
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
int fun = AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC; //公共属性
//设置设备音量 - 14
AttrBean attrBean = new AttrBean();
attrBean.setType(AttrAndFunCode.SYS_INFO_ATTR_VOLUME);
attrBean.setAttrData(new byte[]{(byte) 0x0E});
List<AttrBean> data = new ArrayList<>();
data.add(attrBean);
//执行设置设备系统属性并等待结果回调
controller.setDevSysInfo(controller.getUsingDevice(), fun, data, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Warning

1. data是由多个 2.3.1.1 LTV格式组成的

2. 请通过 CommandBuilder 构建设置设备系统属性命令

SetSysInfoParam

设置系统信息参数

public class SetSysInfoParam extends BaseParameter {

    private byte function; //功能码
    private List<AttrBean> attrBeanList; //功能属性
}

2.3.5.4 监听设备系统属性变化

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 添加蓝牙RCSP事件回调器
manager.addEventListener(new BTRcspEventCallback() {
    //回调设备发送的命令
    @Override
    public void onDeviceCommand(BluetoothDevice device, CommandBase cmd) {
        super.onDeviceCommand(device, cmd);
        //Step2: 处理命令
        if (cmd.getId() != Command.CMD_SYS_INFO_AUTO_UPDATE) {
            //过滤命令
            return;
        }
        //只处理目标命令 - 通知设备系统信息
        UpdateSysInfoCmd updateSysInfoCmd = (UpdateSysInfoCmd) cmd;
        //Step4: 获取参数
        UpdateSysInfoParam param = updateSysInfoCmd.getParam();
        if (null == param) return; //异常处理
        //Step5: 处理数据
//        param.getFunction();  //功能码
//        param.getParamData(); //功能属性
    }
});

Note

1. 结果解析与 2.3.5.2 查询设备系统信息回复结果解析一致

2. 解析结果流程, 请参考demo

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDeviceModeChange(BluetoothDevice device, int mode) {
        //回调设备模式
    }

    @Override
    public void onVolumeChange(BluetoothDevice device, VolumeInfo volume) {
        //回调设备音量信息
    }

    @Override
    public void onEqChange(BluetoothDevice device, EqInfo eqInfo) {
        //回调均衡器调节参数
    }

    @Override
    public void onDevStorageInfoChange(BluetoothDevice device, DevStorageInfo storageInfo) {
        //回调设备存储信息
    }

    @Override
    public void onFileFormatChange(BluetoothDevice device, String fileFormat) {
        //回调支持的播放格式
    }

    @Override
    public void onMusicNameChange(BluetoothDevice device, MusicNameInfo nameInfo) {
        //回调音乐名信息
    }

    @Override
    public void onMusicStatusChange(BluetoothDevice device, MusicStatusInfo statusInfo) {
        //回调音乐状态信息
    }

    @Override
    public void onPlayModeChange(BluetoothDevice device, PlayModeInfo playModeInfo) {
        //回调播放模式信息
    }

    @Override
    public void onAuxStatusChange(BluetoothDevice device, boolean isPlay) {
        //回调外接设备播放状态
    }

    @Override
    public void onFmChannelsChange(BluetoothDevice device, List<ChannelInfo> channels) {
        //回调FM频道列表信息
    }

    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //回调FM状态信息
    }

    @Override
    public void onAlarmListChange(BluetoothDevice device, AlarmListInfo alarmListInfo) {
        //回调闹钟列表信息
    }

    @Override
    public void onAlarmDefaultBellListChange(BluetoothDevice device, List<DefaultAlarmBell> bells) {
        //回调闹钟默认铃声列表
    }

    @Override
    public void onAlarmNotify(BluetoothDevice device, AlarmBean alarmBean) {
        //回调闹钟提醒
    }

    @Override
    public void onAlarmStop(BluetoothDevice device, AlarmBean alarmBean) {
        //回调闹钟停止
    }

    @Override
    public void onID3MusicInfo(BluetoothDevice device, ID3MusicInfo id3MusicInfo) {
        //回调ID3音乐信息
    }

    @Override
    public void onHighAndBassChange(BluetoothDevice device, int high, int bass) {
        //回调高低音信息
    }

    @Override
    public void onEqPresetChange(BluetoothDevice device, EqPresetInfo eqPresetInfo) {
        //回调均衡器预设值信息
    }

    @Override
    public void onPhoneCallStatusChange(BluetoothDevice device, int status) {
        //回调电话状态
    }

    @Override
    public void onExpandFunction(BluetoothDevice device, int type, byte[] data) {
        //回调拓展功能信息
    }

    @Override
    public void onLightControlInfo(BluetoothDevice device, LightControlInfo lightControlInfo) {
        //回调灯光控制信息
    }

    @Override
    public void onSoundCardEqChange(BluetoothDevice device, EqInfo eqInfo) {
        //回调声卡信息
    }

    @Override
    public void onSoundCardStatusChange(BluetoothDevice device, long mask, byte[] values) {
        //回调声卡的状态信息
    }

    @Override
    public void onCurrentVoiceMode(BluetoothDevice device, VoiceMode voiceMode) {
        //回调当前噪声处理模式信息
    }

    @Override
    public void onVoiceModeList(BluetoothDevice device, List<VoiceMode> voiceModes) {
        //回调噪声处理列表信息
    }

    @Override
    public void onSearchDevice(BluetoothDevice device, SearchDevParam searchDevParam) {
        //回调查找设备参数
    }

    @Override
    public void onReverberation(BluetoothDevice device, ReverberationParam param) {
        //回调混响参数
    }

    @Override
    public void onDynamicLimiter(BluetoothDevice device, DynamicLimiterParam param) {
        //回调动态限幅参数
    }
});

SysInfoResponse

系统信息

public class SysInfoResponse extends CommonResponse {
    private byte function; //功能码
    private List<AttrBean> attrs; //功能属性
}

2.3.5.5 设置功能

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造设置功能命令
//功能码
int function = AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC; //公共属性
//标识
int flag = 0;
// 拓展参数
byte[] extend = null;
CommandBase setFunctionCmd = CommandBuilder.buildFunctionCmd((byte) function, (byte) flag, extend);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), setFunctionCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//Step1: 构造设置功能命令
//功能码
int function = AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC; //公共属性
//标识
int flag = 0;
// 拓展参数
byte[] extend = null;
CommandBase setFunctionCmd = CommandBuilder.buildFunctionCmd((byte) function, (byte) flag, extend);
//Step2: 执行操作命令并等待结果回调
controller.sendRcspCommand(manager.getConnectedDevice(), setFunctionCmd, BluetoothConstant.DEFAULT_SEND_CMD_TIMEOUT, new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

FunctionParam

功能参数

public class FunctionParam extends BaseParameter {

    private byte function; //功能号
    private byte cmd; //attr type
    private byte[] extend; //payload
}

2.3.5.6 查询当前设备模式

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_CUR_MODE_TYPE – 标识当前设备模式信息

命令构造

//构造获取当前设备模式
CommandBase getCurrentModeCmd = CommandBuilder.buildGetSysInfoCmd(AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC,
               0x01 << AttrAndFunCode.SYS_INFO_ATTR_CUR_MODE_TYPE);

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDeviceModeChange(BluetoothDevice device, int mode) {
        //回调设备模式
    }
});
//执行获取设备模式信息并等待结果回调
controller.getCurrentDevModeInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onDeviceModeChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.5.7 切换设备模式

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC        – 公共属性
flag :  设备模式, 参考 3.5   功能码
extend :  NULL

命令构造

byte mode = AttrAndFunCode.SYS_INFO_FUNCTION_BT;   //-- 蓝牙模式
//            AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC -- 设备音乐模式
//            AttrAndFunCode.SYS_INFO_FUNCTION_RTC   -- 时钟模式(闹钟，秒表)
//            AttrAndFunCode.SYS_INFO_FUNCTION_AUX   -- 外部输入控制模式
//            AttrAndFunCode.SYS_INFO_FUNCTION_FM    -- FM控制模式
//            AttrAndFunCode.SYS_INFO_FUNCTION_LIGHT -- 灯光模式
CommandBase switchDevModeCmd = CommandBuilder.buildSwitchModeCmd(mode);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDeviceModeChange(BluetoothDevice device, int mode) {
        //回调设备模式
    }
});
//byte SYS_INFO_FUNCTION_BT :  0 //Bluetooth mode
//byte SYS_INFO_FUNCTION_MUSIC : 1 //Music mode
//byte SYS_INFO_FUNCTION_RTC : 2   //clock mode
//byte SYS_INFO_FUNCTION_AUX : 3   //Linein mode
//byte SYS_INFO_FUNCTION_FM  : 4   //FM mode
//byte SYS_INFO_FUNCTION_LIGHT : 5 //Light mode
//执行切换设备模式功能并等待结果回调
controller.switchDeviceMode(controller.getUsingDevice(), mode, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onDeviceModeChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.5.8 查询存储设备信息

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_MUSIC_DEV_STATUS – 标识存储设备信息(U盘, sd卡, flash等)

命令构造

//构造查询存储设备信息
CommandBase getMusicDevStatusCmd = CommandBuilder.buildGetSysInfoCmd(AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC,
              0x01 << AttrAndFunCode.SYS_INFO_ATTR_MUSIC_DEV_STATUS);

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDevStorageInfoChange(BluetoothDevice device, DevStorageInfo storageInfo) {
        //回调设备存储信息
    }
});
//执行获取设备存储信息并等待结果回调
controller.getDevStorageInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onDevStorageInfoChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

设备存储器信息

public class DevStorageInfo implements Parcelable {
    /**
     * 存储器状态
     */
    @NonNull
    private List<> storageStates = new ArrayList<>();
    /**
     * 是否复用
     */
    private boolean isDeviceReuse;
}

Note

存储器状态, 2.4.1.4 SDCardBean

2.3.5.9 重启设备

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构建重启命令
CommandBase rebootCmd = CommandBuilder.buildRebootCmd();
//Step2: 发送重启命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), rebootCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行重启设备功能并等待结果回调
controller.rebootDevice(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.6 音量控制功能

2.3.6.1 获取当前设备音量

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_VOLUME – 标识系统音量

命令构造

//构造获取当前设备音量
CommandBase getVolumeCmd = CommandBuilder.buildGetVolumeCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onVolumeChange(BluetoothDevice device, VolumeInfo volume) {
        //此处将回调设备音量信息
    }
});
//执行获取当前音量功能并等待结果回调
controller.getCurrentVolume(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onVolumeChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

音量信息, VolumeInfo

VolumeInfo

音量信息

public class VolumeInfo {
    private int maxVol;  //最大音量
    private int volume; //当前音量
    private boolean supportVolumeSync=false; //是否支持音量同步
}

2.3.6.2 调节设备音量

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC  – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_VOLUME          – 标识系统音量
value : volume (1Byte) – 音量

命令构造

//构造设置当前设备音量
int volume = 16; //音量等级, 最大音量等级可以在设备信息中获得
CommandBase setVolumeCmd = CommandBuilder.buildSetVolumeCmd(volume);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onVolumeChange(BluetoothDevice device, VolumeInfo volume) {
        //此处将回调设备音量信息
    }
});
VolumeInfo volume = null; //音量信息，不能为空
//执行调节音量功能并等待结果回调
controller.adjustVolume(controller.getUsingDevice(), volume, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onVolumeChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

音量信息, VolumeInfo

2.3.6.3 获取高低音信息

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_HIGH_AND_BASS – 标识高低音功能

命令构造

CommandBase getHighAndBassCmd = CommandBuilder.buildGetHighAndBassCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onHighAndBassChange(BluetoothDevice device, int high, int bass) {
        //此处将会回调高低音信息
    }
});
//执行获取高低音信息功能并等待结果回调
controller.getHighAndBassValue(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onHighAndBassChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.6.4 设置高低音

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC  – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_HIGH_AND_BASS   – 标识高低音功能
value : bass (4Bytes)  + high(4Bytes) / 低音值 + 高音值

命令构造

int high = 16; //高音值
int bass = 16; //低音值
CommandBase setHighAndBassCmd = CommandBuilder.buildSetHighAndBassCmd(high, bass);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onHighAndBassChange(BluetoothDevice device, int high, int bass) {
        //此处将会回调高低音信息
    }
});
int high = 16; //高音值
int bass = 16; //低音值
//执行设置高低音功能并等待结果回调
controller.setHighAndBassValue(controller.getUsingDevice(), high, bass, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onHighAndBassChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.7 设备音乐控制功能

2.3.7.1 获取设备音乐信息

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC – 设备音乐模式

mask : – 标识功能码

掩码位	说明
Bit0	音乐播放状态
Bit1	音乐名称信息
Bit2	EQ信息
Bit3	文件类型
Bit4	播放模式

命令构造

CommandBase getMusicInfoCmd = CommandBuilder.buildGetMusicSysInfoCmd(0x07);

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onMusicNameChange(BluetoothDevice device, MusicNameInfo nameInfo) {
        //此处将回调音乐名信息
    }

    @Override
    public void onMusicStatusChange(BluetoothDevice device, MusicStatusInfo statusInfo) {
        //此处将回调音乐播放状态
    }

    @Override
    public void onPlayModeChange(BluetoothDevice device, PlayModeInfo playModeInfo) {
        //此处将回调播放模式信息
    }
});
//执行获取设备音乐信息功能并等待结果回调
controller.getDeviceMusicInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onMusicNameChange、
        // BTRcspEventCallback#onMusicStatusChange、BTRcspEventCallback#onPlayModeChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

MusicNameInfo
MusicStatusInfo
PlayModeInfo

MusicNameInfo

音乐名称信息

public class MusicNameInfo {
    private int cluster;  //簇号 -- 用于定位文件路径
    private String name;  //音乐名
}

MusicStatusInfo

音乐状态信息

public class MusicStatusInfo {
    private boolean isPlay;  //是否播放
    private int currentTime; //当前播放时间(单位: 毫秒)
    private int totalTime; //时间总长(单位: 毫秒)
    private int currentDev; //设备句柄
}

PlayModeInfo

播放模式信息

public class PlayModeInfo {
     private int playMode; //播放模式
}

Note

播放模式对照表

播放模式对照表

数值	模式名称
0	无效模式
1	全部循环
2	设备循环
3	单曲循环
4	随机播放
5	文件夹循环

2.3.7.2 获取设备音乐播放状态

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC – 设备音乐模式

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_MUSIC_STATUS_INFO – 标识音乐播放状态

命令构造

CommandBase getMusicPlaybackStatusCmd = CommandBuilder.buildGetMusicStatusInfoCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onMusicStatusChange(BluetoothDevice device, MusicStatusInfo statusInfo) {
        //此处将回调音乐播放状态
    }
});
//执行获取设备音乐播放状态功能并等待结果回调
controller.getDeviceMusicStatusInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onMusicStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

音乐播放状态, MusicStatusInfo

2.3.7.3 获取支持的播放格式

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_FILE_TYPE – 标识支持的文件格式

命令构造

CommandBase getBrowseFileTypeCmd = CommandBuilder.buildGetBrowseFileTypeCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onFileFormatChange(BluetoothDevice device, String fileFormat) {
        //此处将回调支持播放文件格式
    }
});
//执行获取支持播放格式功能并等待结果回调
controller.getPlayFileFormat(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFileFormatChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.7.4 音乐播放或者暂停

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC        – 音乐模式
flag :  AttrAndFunCode.FUNCTION_MUSIC_CMD_PLAY_OR_PAUSE
extend :  NULL

命令构造

CommandBase musicPlayOrPauseCmd = CommandBuilder.buildPlayOrPauseCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行音乐播放或暂停功能并等待结果回调
controller.musicPlayOrPause(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.7.5 播放上一曲

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC        – 音乐模式
flag :  AttrAndFunCode.FUNCTION_MUSIC_CMD_PLAY_PREV
extend :  NULL

命令构造

CommandBase musicPlayPrevCmd = CommandBuilder.buildPlayPrevCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行播放上一曲功能并等待结果回调
controller.musicPlayPrev(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.7.6 播放下一曲

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC        – 音乐模式
flag :  AttrAndFunCode.FUNCTION_MUSIC_CMD_PLAY_NEXT
extend :  NULL

命令构造

CommandBase musicPlayNextCmd = CommandBuilder.buildPlayNextCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行播放下一曲功能并等待结果回调
controller.musicPlayNext(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.7.7 切换下一个播放模式

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC        – 音乐模式
flag :  AttrAndFunCode.FUNCTION_MUSIC_CMD_NEXT_PLAYMODE
extend :  NULL

命令构造

CommandBase musicNextPlaymodeCmd = CommandBuilder.buildNextPlaymodeCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行切换下一个播放模式功能并等待结果回调
controller.musicSwitchNextPlayMode(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.7.8 跳转到指定时间

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_MUSIC        – 音乐模式
flag :  AttrAndFunCode.FUNCTION_MUSIC_CMD_FAST_FORWARD or FUNCTION_MUSIC_CMD_RETREAT_QUICKLY
extend :  指定时间(2Bytes)

命令构造

int orientation = Constants.SEEK_ORIENTATION_BACK;//跳转方向
short time = 1234; //跳转时间戳
CommandBase command = orientation == Constants.SEEK_ORIENTATION_BACK ?
   CommandBuilder.buildFastForwardCmd(time) : CommandBuilder.buildRetreatQuicklyCmd(time);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
int orientation = Constants.SEEK_ORIENTATION_FORWARD;
//orientation ： Constants.SEEK_ORIENTATION_FORWARD - 往前，Constants.SEEK_ORIENTATION_BACK - 往后
short time = 3000;
//time ： 时间戳
//执行跳转到指定时间戳功能并等待结果回调
controller.musicSeekToProgress(controller.getUsingDevice(), orientation, time, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.8 均衡器调试功能

2.3.8.1 获取均衡器参数

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_EQ_PRESET_VALUE | 0x01 << AttrAndFunCode.SYS_INFO_ATTR_EQ – EQ预设值和EQ信息

命令构造

CommandBase getEqInfoCmd = CommandBuilder.buildGetEqPresetAndEqValueCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onEqPresetChange(BluetoothDevice device, EqPresetInfo eqPresetInfo) {
        //此处将会回调均衡器预设值
    }

    @Override
    public void onEqChange(BluetoothDevice device, EqInfo eqInfo) {
        //此处将会回调均衡器效果信息
    }
});
//执行获取均衡器信息功能并等待结果回调
controller.getEqInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onEqPresetChange、BTRcspEventCallback#onEqChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.8.2 配置均衡器参数

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC  – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_EQ              – 标识均衡器参数
value :  参数

是否动态调整	参数格式	备注
false	eqMode(1Byte) + eqValue(10 bytes)	eqMode最高bit为0, 表示默认参数
true	eqMode(1Byte) + length(1Byte) + eqValue(n Bytes)	eqMode最高bit为1, 表示动态调整, `推荐`

命令构造

boolean isDynamic = true; //是否支持动态变化
int eqMode = 6;  //EQ模式 -- 自定义
byte[] gains = new byte[10]; //EQ增益数组 - 根据动态段数决定
CommandBase setEqInfoCmd = CommandBuilder.buildSetEqValueCmd(isDynamic, (byte) eqMode, gains)();

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onEqChange(BluetoothDevice device, EqInfo eqInfo) {
        //此处将会回调均衡器效果信息
    }
});
EqInfo eqInfo = null; //EQ信息，不能为空
//执行配置均衡器效果功能并等待结果回调
controller.configEqInfo(controller.getUsingDevice(), eqInfo, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

2.3.8.3 EqInfo

2.3.8.3 EqInfo

均衡器信息

public class EqInfo {

    /**
     * EQ模式
     */
    private int mode;
    /**
     * 增益值数组
     */
    private byte[] value = new byte[10];
    /**
     * 预设值数组
     */
    private int[] freqs = BluetoothConstant.DEFAULT_EQ_FREQS;
    /**
     * 是否动态EQ
     */
    private boolean dynamic;
    /**
     * 预设值数组长度
     */
    private int count = 10;
}

Note

2.3.8.4 EQ模式对照表

2.3.8.4 EQ模式对照表

数值	模式名称
0	标准音乐模式(Standard Music Mode)
1	摇滚音乐模式(Rock Music Mode)
2	流行音乐模式(Popular Music Mode)
3	古典音乐模式(Classical Music Mode)
4	爵士音乐模式(Jazz Music Mode)
5	乡村音乐模式(Country Music Mode)
6	自定义音乐模式(Custom Music Mode)

2.3.8.5 获取拓展参数

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_FIXED_LEN_DATA_FUN – 拓展参数

命令构造

CommandBase getFixedLenDataCmd = CommandBuilder.buildGetFixedLenDataCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onExpandFunction(BluetoothDevice device, int type, byte[] data) {
        //此处将会回调额外功能信息
    }
});
//执行获取额外功能信息功能并等待结果回调
controller.getExpandDataInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onExpandFunction回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.8.6 设置拓展参数

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC        – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_FIXED_LEN_DATA_FUN    – 标识拓展参数
value :  mask(4Bytes) + data(n Bytes)

命令构造

int mask = 0x03; //拓展掩码  - Bit0 --混响   Bit1 -- 动态限幅
byte[] data = new byte[0]; //参数, 格式： LTV格式, 由多个LTV数据组成
CommandBase setFixedLenDataCmd = CommandBuilder.buildSetFixedLenDataCmd(mask, data);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//mask - 功能掩码
//data - 参数数据
//执行设置额外功能信息功能并等待结果回调
controller.setExpandDataInfo(controller.getUsingDevice(), mask, data, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Warning

数据由多个 2.3.1.1   LTV格式 数据组成
mask为32Bit的值, 混响功能是Bit0, 动态限幅功能是Bit1
需要判断设备是否支持该功能

2.3.8.7 设置混响

仅RCSPController支持接口方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//混响参数，不能为空
ReverberationParam param = null;
//执行设置混响功能并等待结果回调
controller.setReverberationParameter(controller.getUsingDevice(), param, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Warning

需要判断设备是否支持该功能(通过获取拓展参数, 是否有对应参数返回来确认)

Note

ReverberationParam

ReverberationParam

混响参数

public class ReverberationParam {
    private boolean isOn;      //开关
    private int depthValue;    //深度值
    private int strengthValue; //强度值
}

2.3.8.8 设置动态限幅

仅RCSPController支持接口方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//动态限幅参数，不能为空
DynamicLimiterParam param = null;
//执行设置动态限幅功能并等待结果回调
controller.setDynamicLimiterParameter(controller.getUsingDevice(), param, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Warning

需要判断设备是否支持该功能(通过获取拓展参数, 是否有对应参数返回来确认)

Note

DynamicLimiterParam

DynamicLimiterParam

动态限幅参数

public class DynamicLimiterParam {
    private int value; //数值
}

2.3.9 时钟功能

2.3.9.1 同步时间

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_RTC           – 时钟功能
type :  AttrAndFunCode.SYS_INFO_ATTR_RTC_TIME              – 标识更新时间
value :  timestamp: year(2Bytes) + month(1Byte) + day(1Byte) + hour(1Byte) + minute(1Byte) + second(1Byte)

命令构造

CommandBase syncTimeCmd = CommandBuilder.buildSyncTimeCmd(Calendar.getInstance());

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行同步时间功能并等待结果回调
controller.syncTime(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.9.2 读取闹钟列表

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_RTC – 时钟功能

mask : – 时钟参数

* AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM              – 闹钟列表
* AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM_EXPAND_FLAG  – 闹钟拓展参数
* AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM_VER          – 闹钟版本

命令构造

CommandBase getAlarmListCmd = CommandBuilder.buildGetAlarmCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onAlarmListChange(BluetoothDevice device, AlarmListInfo alarmListInfo) {
        //此处将会回调闹钟列表信息
    }
});
//执行获取闹钟列表功能并等待结果回调
controller.readAlarmList(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会BTRcspEventCallback#onAlarmListChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

闹钟列表信息, AlarmListInfo

AlarmListInfo

闹钟列表信息

 public class AlarmListInfo {

     private int version; //版本号
     private List<AlarmBean> alarmBeans; //闹钟列表

}

AlarmBean

闹钟信息

public class AlarmBean {
    //索引
    private byte index;
    //名称
    private String name;
    //小时
    private byte hour;
    //分钟
    private byte min;
    //类型
    private byte repeatMode;
    //拓展字段
    private String reserved;
    //是否开启
    private boolean open;
    //铃声类型
    private byte bellType;//0: 默认类型  1：设备文件类型
    //铃声簇号
    private int bellCluster; //当bellType=0时，这里是铃声序号 当bellType=1时 这里是文件簇号
    //铃声名称
    private String bellName; //当bellType=1时有效
    //铃声所在设备序号
    private byte devIndex;//当bellType=1时有效

    private int version;
}

2.3.9.3 添加或者修改闹钟

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_RTC     – 时钟功能
type :  AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM       – 标识闹钟操作
value :  op(1Byte)+len(1Byte)+payload(n Bytes)

命令构造

AlarmBean alarm; //闹钟属性，创建或者读取闹钟列表获取
CommandBase addAlarmCmd = CommandBuilder.buildSetAlarmCmd(AlarmBean.toAttrbean(alarm, false));

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
AlarmBean alarm; //闹钟属性，创建或者读取闹钟列表获取
//执行添加或修改闹钟功能并等待结果回调
controller.addOrModifyAlarm(controller.getUsingDevice(), alarm, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

闹钟对象 AlarmBean

2.3.9.4 删除闹钟

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_RTC        – 时钟功能
type :  AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM          – 标识闹钟操作
value :  op(1Byte)+len(1Byte)+payload(n Bytes)

命令构造

AlarmBean alarm; //闹钟属性, 通过读取闹钟列表获取
CommandBase deleteAlarmCmd = CommandBuilder.buildSetAlarmCmd(AlarmBean.toAttrbean(alarm, true));

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
AlarmBean alarm ; //闹钟属性, 通过读取闹钟列表获取
//执行删除闹钟功能并等待结果回调
controller.deleteAlarm(controller.getUsingDevice(), alarm, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

闹钟信息 AlarmBean

2.3.9.5 读取闹钟默认铃声列表

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_RTC – 时钟功能

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM_DEFAULT_BELL_LIST – 时钟参数

命令构造

CommandBase readAlarmDefaultBellListCmd = CommandBuilder.buildGetDefaultBellList();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onAlarmDefaultBellListChange(BluetoothDevice device, List<DefaultAlarmBell> bells) {
        //此处将会回调默认闹钟铃声列表信息
    }
});
//执行获取默认闹钟铃声列表功能并等待结果回调
controller.readAlarmDefaultBellList(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会BTRcspEventCallback#onAlarmDefaultBellListChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

默认闹钟铃声， DefaultAlarmBell

DefaultAlarmBell

默认闹钟铃声

public class DefaultAlarmBell {
    private String name; //名称
    private int index; //索引
    private boolean selected; //是否选择
}

2.3.9.6 读取指定闹钟铃声参数

JL_BluetoothManager方式

命令构造

byte mask = 0; //闹钟序号
CommandBase readAlarmBellArgs = CommandBuilder.buildReadBellArgsCmd(mask);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//alarmIndex - 闹钟序号
//执行获取指定闹钟的铃声参数功能并等待结果回调
controller.readAlarmBellArgs(controller.getUsingDevice(), alarmIndex, new OnRcspActionCallback<List<AlarmExpandCmd.BellArg>>() {
    @Override
    public void onSuccess(BluetoothDevice device, List<AlarmExpandCmd.BellArg> message) {
        //成功回调
        //message - 铃声参数
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

BellArg

铃声参数

public static class BellArg {
    /**
     * 闹钟索引
     */
    private int index;
    /**
     * 是否允许设置循环次数
     */
    private boolean isCanSetCount;
    /**
     * 循环次数
     */
    private int count;
    /**
     * 是否允许设置重复间隔
     */
    private boolean isCanSetInterval;
    /**
     * 重复间隔
     */
    private int interval;
    /**
     * 是否允许设置响铃时长
     */
    private boolean isCanSetDuration;
    /**
     * 响铃时长
     */
    private int duration;
}

2.3.9.7 设置指定闹钟铃声参数

JL_BluetoothManager方式

命令构造

AlarmExpandCmd.BellArg arg; //闹钟铃声参数
CommandBase setAlarmBellArgCmd = CommandBuilder.buildSetBellArgsCmd(arg);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//alarmBellArg - 通过读取闹钟铃声参数获得
 AlarmExpandCmd.BellArg alarmBellArg; //闹钟铃声参数
//执行设置指定闹钟的铃声参数功能并等待结果回调
controller.setAlarmBellArg(controller.getUsingDevice(), alarmBellArg, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

闹钟铃声参数， BellArg

2.3.9.8 试听闹钟铃声

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_RTC         – 时钟功能
type :  AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM_AUDITION  – 标识试听闹钟铃声
value :  op(1Byte)+type(1Byte)+dev(1Byte)+cluster(4Bytes)

命令构造

int type = 0;    //播放类型
int dev = 0;     //存在设备标识
int cluster = 0; //簇号
CommandBase auditionAlarmBellCmd = CommandBuilder.buildAuditionAlarmBellCmd(type, dev, cluster);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
AuditionParam param = null; //试听参数
//执行试听闹钟铃声功能并等待结果回调
controller.auditionAlarmBell(controller.getUsingDevice(), param, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

AuditionParam

试听铃声参数

public class AuditionParam implements Parcelable {
    private byte op; //操作码， 0 : 停止   1 : 响铃
    private byte type; //铃声类型， 0 : 默认   1 : 文件
    private byte dev;  //存储器索引
    private int cluster; //文件簇号
    private String name; //铃声名称
}

Note

试听铃声参数， AuditionParam

2.3.9.9 停止试听闹钟铃声

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_RTC         – 时钟功能
type :  AttrAndFunCode.SYS_INFO_ATTR_RTC_ALARM_AUDITION  – 标识试听闹钟铃声
value :  op(1Byte), op = 0x00

命令构造

CommandBase stopAuditionAlarmBellCmd = CommandBuilder.buildStopAuditionAlarmBellCmd();

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
    //执行停止试听闹钟铃声功能并等待结果回调
controller.stopAlarmBell(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.10 外接设备控制功能

2.3.10.1 获取外接设备播放状态

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_AUX – AUX功能

mask : 0x01 – 播放状态

命令构造

CommandBase getAuxPlayStatueCmd = CommandBuilder.buildGetAuxPlayStatueCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onAuxStatusChange(BluetoothDevice device, boolean isPlay) {
        //此处回调外接设备播放状态
    }
});
//执行获取外接设备播放状态功能并等待结果回调
controller.getAuxStatusInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onAuxStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.10.2 外接设备播放或暂停

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_AUX        – AUX功能
type :  AttrAndFunCode.FUNCTION_AUX_CMD_PAUSE_OR_PLAY   – 播放或暂停
value :  NULL

命令构造

CommandBase auxPlayOrPauseCmd = CommandBuilder.buildAuxPlayOrPauseCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行外接设备播放或暂停功能并等待结果回调
controller.auxPlayOrPause(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.11 FM控制功能

2.3.11.1 获取FM状态信息

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_FM – FM功能

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_FM_STATU – 播放状态

命令构造

CommandBase getFmStatueCmd = CommandBuilder.buildGetFmStatueCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行获取FM状态信息功能并等待结果回调
controller.getFmInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

FmStatusInfo

FM状态信息

public class FmStatusInfo {
    private boolean isPlay; //是否正在播放
    private int channel;    //频点
    private float freq;     //频率
    private int mode;       //模式
}

2.3.11.2 向前搜索频道

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM    – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_FREQ_SCAN   – 频道搜索
value :  way(1Byte), 0x01                              – 向前搜索

命令构造

CommandBase fmForwardSearchChannelsCmd = CommandBuilder.buildFmScanCmd((byte) 0x01);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmChannelsChange(BluetoothDevice device, List<ChannelInfo> channels) {
        //此处回调已发现的FM频道列表
    }
});
//执行向前搜索FM频道功能并等待结果回调
controller.fmForwardSearchChannels(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmChannelsChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Important

不推荐使用
ChannelInfo

2.3.11.3 向后搜索频道

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM    – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_FREQ_SCAN   – 频道搜索
value :  way(1Byte), 0x02                              – 向后搜索

命令构造

CommandBase fmBackwardSearchChannelsCmd = CommandBuilder.buildFmScanCmd((byte) 0x02);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmChannelsChange(BluetoothDevice device, List<ChannelInfo> channels) {
        //此处回调已发现的FM频道列表
    }
});
//执行向后搜索FM频道功能并等待结果回调
controller.fmBackwardSearchChannels(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmChannelsChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Important

不推荐使用
ChannelInfo

ChannelInfo

频道信息

public class ChannelInfo {
    /**
     * 序号
     */
    private int index;
    /**
     * 频点
     */
    private float freq;
}

2.3.11.4 搜索FM频道

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM    – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_FREQ_SCAN   – 频道搜索
value :  way(1Byte), 0x00                              – 全段搜索

命令构造

CommandBase fmScanCmd = CommandBuilder.buildFmScanCmd((byte) 0x00);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmChannelsChange(BluetoothDevice device, List<ChannelInfo> channels) {
        //此处回调已发现的FM频道列表
    }
});
//执行搜索FM频道功能并等待结果回调
controller.fmSearchAllChannels(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmChannelsChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Important

推荐使用
ChannelInfo

2.3.11.5 停止搜索频道

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM    – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_FREQ_SCAN   – 频道搜索
value :  way(1Byte), 0x03                              – 停止搜索

命令构造

CommandBase fmstopScanCmd = CommandBuilder.buildFmScanCmd((byte) 0x03);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行停止搜索FM频道功能并等待结果回调
controller.fmStopSearch(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.11.6 FM播放或暂停

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM        – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_PLAY_OR_PAUSE   – 播放或暂停
value :  NULL

命令构造

CommandBase fmPlayOrPauseCmd = CommandBuilder.buildFmPlayOrPauseCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行FM播放或暂停功能并等待结果回调
controller.fmPlayOrPause(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

2.3.11.7 播放上一个频道

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM        – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_PREV_CHANNEL    – 播放上一个频道
value :  NULL

命令构造

CommandBase fmPrevChannelCmd = CommandBuilder.buildFmPrevChannelCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行播放上一个频道功能并等待结果回调
controller.fmPlayPrevChannel(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

2.3.11.8 播放下一个频道

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM        – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_NEXT_CHANNEL    – 播放下一个频道
value :  NULL

命令构造

CommandBase fmNextChannelCmd = CommandBuilder.buildFmNextChannelCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行播放下一个频道功能并等待结果回调
controller.fmPlayNextChannel(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

2.3.11.9 播放上一个频点

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM        – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_PREV_FREQ       – 播放上一个频点
value :  NULL

命令构造

CommandBase fmPrevFreqCmd = CommandBuilder.buildFmPrevFreqCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行播放上一个频点功能并等待结果回调
controller.fmPlayPrevFrequency(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

2.3.11.10 播放下一个频点

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM        – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_NEXT_FREQ       – 播放下一个频点
value :  NULL

命令构造

CommandBase fmNextFreqCmd = CommandBuilder.buildFmNextFreqCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行播放下一个频点功能并等待结果回调
controller.fmPlayNextFrequency(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

2.3.11.11 播放指定频点

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_FM        – FM功能
type :  AttrAndFunCode.FUNCTION_FM_CMD_SELECT_FREQL    – 播放指定频点
value :  freqency(2Bytes), 浮点数转整数, 扩大10倍

命令构造

float frequency = 87.5f;
CommandBase fmSelectFreqCmd = CommandBuilder.buildFmSelectFreqCmd(frequency);

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFmStatusChange(BluetoothDevice device, FmStatusInfo fmStatusInfo) {
        //此处回调FM状态信息
    }
});
//执行播放指定的频点功能并等待结果回调
controller.fmPlaySelectedFrequency(controller.getUsingDevice(), freq, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFmStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

FmStatusInfo

2.3.11.12 获取发射频点

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_FM_TX – 发射频点

命令构造

CommandBase getFrequencyTxInfoCmd = CommandBuilder.buildGetFrequencyTxInfoCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFrequencyTx(BluetoothDevice device, float frequency) {
        //此处回调发射频点
    }
});
//执行获取发射频点功能并等待结果回调
controller.getFmFrequency(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFrequencyTx回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.11.13 设置发射频点

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC    – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_FM_TX             – 发射频点
value :  freqency(2Bytes), 浮点数转整数, 扩大10倍

命令构造

float frequency = 87.5f;
CommandBase setFrequencyTxInfoCmd = CommandBuilder.buildSetFrequencyTxInfoCmd(frequency);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onFrequencyTx(BluetoothDevice device, float frequency) {
        //此处回调发射频点
    }
});
//执行设置指定发送频点并等待结果回调
controller.setFmFrequency(controller.getUsingDevice(), frequency, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onFrequencyTx回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.12 灯光控制功能

2.3.12.1 获取灯光控制信息

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_LIGHT – 灯光控制

命令构造

CommandBase getLightControlInfoCmd = CommandBuilder.buildGetLightControlInfoCmd();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//添加蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onLightControlInfo(BluetoothDevice device, LightControlInfo lightControlInfo) {
        //此处将会回调灯光控制信息
    }
});
//执行获取灯光控制信息功能并等待结果回调
controller.getLightControlInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onLightControlInfo回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.12.2 设置灯光控制

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC    – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_LIGHT             – 灯光控制
value :  data(n Bytes)                                     – 控制数据

命令构造

LightControlInfo lightControlInfo;
CommandBase setLightControlInfoCmd = CommandBuilder.buildSetLightControlInfoCmd(lightControlInfo.toByteArray());

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行设置灯光控制功能并等待结果回调
controller.setLightControlInfo(controller.getUsingDevice(), lightControlInfo, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

2.3.12.3 灯光控制信息

2.3.12.3 灯光控制信息

public class LightControlInfo {
    /*状态*/
    public final static int STATE_OFF = 0;      //关闭
    public final static int STATE_ON = 1;       //打开
    public final static int STATE_SETTING = 2;  //设置模式

    /*灯模式*/
    public final static int LIGHT_MODE_COLOURFUL = 0; //彩色
    public final static int LIGHT_MODE_TWINKLE = 1;   //闪烁
    public final static int LIGHT_MODE_SCENE = 2;     //情景

    /*闪烁模式*/
    public final static int TWINKLE_MODE_COLORFUL = 0; //七彩
    public final static int TWINKLE_MODE_RED = 1;      //红色
    public final static int TWINKLE_MODE_ORANGE = 2;   //橙色
    public final static int TWINKLE_MODE_YELLOW = 3;   //黄色
    public final static int TWINKLE_MODE_GREEN = 4;    //绿色
    public final static int TWINKLE_MODE_CYAN = 5;     //青色
    public final static int TWINKLE_MODE_BLUE = 6;     //蓝色
    public final static int TWINKLE_MODE_PURPLE = 7;   //紫色

    /*闪烁频率*/
    public final static int TWINKLE_FREQ_FAST = 0;     //快闪
    public final static int TWINKLE_FREQ_SLOW = 1;     //慢速
    public final static int TWINKLE_FREQ_BREATHE = 2;  //呼吸闪灯
    public final static int TWINKLE_FREQ_MUSIC = 3;    //音乐闪烁

    /*场景模式*/
    public final static int SCENE_MODE_RAINBOW = 0;              //彩虹
    public final static int SCENE_MODE_HEARTBEAT = 1;            //心跳
    public final static int SCENE_MODE_CANDLELIGHT = 2;          //烛火
    public final static int SCENE_MODE_NIGHT_LIGHT = 3;          //夜灯
    public final static int SCENE_MODE_STAGE = 4;                //舞台
    public final static int SCENE_MODE_COLORFUL_BREATHING = 5;   //漫彩呼吸
    public final static int SCENE_MODE_RED_BREATHING = 6;        //漫红呼吸
    public final static int SCENE_MODE_GREEN_BREATHING = 7;      //漫绿呼吸
    public final static int SCENE_MODE_BLUE_BREATHING = 8;       //漫蓝呼吸
    public final static int SCENE_MODE_GREEN_MOOD = 9;           //绿色心情
    public final static int SCENE_MODE_BEAUTIFUL_SUNSET = 10;    //夕阳美景
    public final static int SCENE_MODE_MUSIC_RHYTHM = 11;        //音乐律动

    private int switchState; //开关状态
    private int lightMode; //灯模式
    private int color; //颜色值
    private int twinkleMode; //闪烁模式
    private int twinkleFreq; //闪烁频率
    private int sceneMode; //场景模式
    private int hue;         //色相, 范围：0-360
    private int saturation;  //饱和度，饱和度：0-100
    private int luminance;   //亮度，亮度：0-100

}

2.3.13 本地音乐控制功能

原名: ID3信息控制功能。用于控制手机第三方播放器。

2.3.13.1 控制ID3信息流推送

JL_BluetoothManager方式

命令构造

boolean isOpenSteam = false;
CommandBase command;
if(isOpenSteam){ //打开ID3信息流推送
    command = CommandBuilder.buildSetDeviceNotifyADVInfoCmd(1);
}else{ //关闭ID3信息流推送
    command = CommandBuilder.buildStopDeviceNotifyADVInfoCmd();
}

代码示例参考 2.3.2 通用命令处理示例

Note

ID3信息流推送开启后, 如果设备接收到ID3音乐信息, 将会在 3.2 蓝牙事件监听器 #onDeviceCommand方法回调

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onID3MusicInfo(BluetoothDevice device, ID3MusicInfo id3MusicInfo) {
        //此处将会回调ID3音乐信息
    }
});
//enable - true : 开启, false : 关闭
//执行控制ID3信息流推送功能并等待结果回调
controller.controlAdvBroadcast(controller.getUsingDevice(), enable, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //enable = true, 开启ID3信息流推送，ID3信息将会在BTRcspEventCallback#onID3MusicInfo回调
        //enable = false, 关闭ID3信息流推送
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.13.2 获取ID3所有信息

JL_BluetoothManager方式

命令构造

CommandBase getID3MusicInfoCmd = CommandBuilder.buildGetBtSysInfoCmd(0x1ff);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onID3MusicInfo(BluetoothDevice device, ID3MusicInfo id3MusicInfo) {
        //此处将会回调ID3音乐信息
    }
});
//执行获取ID3所有信息功能并等待结果回调
controller.getID3MusicInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onID3MusicInfo回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

2.3.13.3 ID3音乐信息

2.3.13.3 ID3音乐信息

public class ID3MusicInfo implements Parcelable {
    //    歌曲名
    private String title;
    //    作曲家
    private String artist;
    //    专辑
    private String album;
    //    序号
    private int number = -1;
    //    歌单总长度
    private int total;
    //    总时长
    private int totalTime;
    //    类型
    private String genre;
    //    当前时间
    private int currentTime = -1;
    //    播放状态
    private boolean playStatus;
}

2.3.13.4 ID3音乐播放或暂停

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_BT             – 蓝牙功能功能
type :  AttrAndFunCode.FUNCTION_BT_CMD_ID3_PLAY_OR_PAUSE    – ID3音乐播放或暂停
value :  NULL

命令构造

CommandBase ID3PlayOrPauseCmd = CommandBuilder.buildID3PlayOrPauseCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行id3音乐播放或暂停功能并等待结果回调
controller.iD3MusicPlayOrPause(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.13.5 ID3音乐播放上一曲

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_BT         – 蓝牙功能功能
type :  AttrAndFunCode.FUNCTION_BT_CMD_ID3_PLAY_PREV    – ID3音乐播放上一曲
value :  NULL

命令构造

CommandBase ID3PlayPrevCmd = CommandBuilder.buildID3PlayPrevCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行id3音乐播放上一曲功能并等待结果回调
controller.iD3MusicPlayPrev(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.13.6 ID3音乐播放下一曲

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_BT         – 蓝牙功能功能
type :  AttrAndFunCode.FUNCTION_BT_CMD_ID3_PLAY_NEXT    – ID3音乐播放下一曲
value :  NULL

命令构造

CommandBase ID3PlayNextCmd = CommandBuilder.buildID3PlayNextCmd();

代码示例参考 2.3.5.5 设置功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行id3音乐播放下一曲功能并等待结果回调
controller.iD3MusicPlayNext(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.14 TWS功能

功能描述	命令原型	命令模型	命令参数	命令回复	备注
获取设备设置信息	Command.CMD_ADV_GET_INFO	GetADVInfoCmd	GetADVInfoParam	ADVInfoResponse	参考 2.3.2 通用命令处理示例
设备广播流控制	Command.CMD_ADV_NOTIFY_SETTINGS	SetDeviceNotifyAdvInfoCmd	SetDeviceNotifyAdvInfoParam	SetDeviceNotifyAdvInfoResponse	参考 2.3.2 通用命令处理示例
设置设备功能	Command.CMD_ADV_SETTINGS	SetADVInfoCmd	SetADVInfoParam	SetADVResponse	参考 2.3.2 通用命令处理示例
监听设备广播信息	Command.CMD_ADV_DEVICE_NOTIFY	NotifyAdvInfoCmd	NotifyAdvInfoParam	NULL	参考 2.3.3 接收命令处理示例
监听设备请求	Command.CMD_ADV_DEV_REQUEST_OPERATION	RequestAdvOpCmd	RequestAdvOpParam	CommonResponse	参考 2.3.3 接收命令处理示例

2.3.14.1 获取设备设置信息

JL_BluetoothManager方式

命令构造

//mask = 0xffffffff;  -- 获取所有属性
CommandBase getTwsInfoCmd = CommandBuilder.buildGetADVInfoCmd(mask);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
int mask = 0x01; //属性掩码， 不能为0
//mask = 0xffffffff; //获取所有属性
//执行获取设备设置信息功能并等待结果回调
controller.getDeviceSettingsInfo(controller.getUsingDevice(), mask, new OnRcspActionCallback<ADVInfoResponse>() {
    @Override
    public void onSuccess(BluetoothDevice device, ADVInfoResponse message) {
        //成功回调
        //message - 设置信息
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Important

1. mask 参考 3.5 功能码 #ADV_TYPE_xxx

2. 结果参考 ADVInfoResponse

ADVInfoResponse

设备设置信息

public class ADVInfoResponse {
    //厂商ID
    private int pid;
    //产品ID
    private int vid;
    //客户ID
    private int uid;
    //左设备（设备1）电量
    private int leftDeviceQuantity;
    //左设备（设备1）充电标识
    private boolean isLeftCharging;
    //右设备（设备2）电量
    private int rightDeviceQuantity;
    //右设备（设备2）充电标识
    private boolean isRightCharging;
    //充电仓（设备3）电量
    private int chargingBinQuantity;
    //充电仓（设备3）充电标识
    private boolean isDeviceCharging;
    //设备名
    private String deviceName;
    //麦通道
    private int micChannel;
    //工作模式
    private int workModel;
    //按键设置
    private List<KeySettings> mKeySettingsList;
    //灯光设置
    private List<LedSettings> mLedSettingsList;
    //入耳检测设置
    private int inEarSettings;
    //语言
    private String language;
    //ANC模式列表
    private byte[] modes;

}

KeySettings

按键设置信息

public static class KeySettings {
    private int keyNum; //按键序号
    private int action; //动作标识
    private int function; //功能标识
    ...
}

LedSettings

灯效设置信息

public static class LedSettings {
    private int scene; //场景标识
    private int effect; //效果标识
    ...
}

2.3.14.2 设备广播流控制

JL_BluetoothManager方式

命令构造

boolean isOpenStream = false; //流开关
CommandBase command = CommandBuilder.buildGetLightControlInfoCmd();
if(isOpenStream){
    command = CommandBuilder.buildSetDeviceNotifyADVInfoCmd(1);
}else{
    command = CommandBuilder.buildStopDeviceNotifyADVInfoCmd();
}

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDeviceBroadcast(BluetoothDevice device, DevBroadcastMsg broadcast) {
        //此处将会回调设备广播信息
    }
});
//enable - 开关
//执行控制设备广播信息功能并等待结果回调
controller.controlAdvBroadcast(controller.getUsingDevice(), enable, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //enable = true, 开启设备广播信息，数据将在BTRcspEventCallback#onDeviceBroadcast回调
        //enable = false, 关闭设备广播信息
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Important

1. 设备连上后会默认开启一段时间广播流, 用于弹窗

2. 开启广播流, 会导致设备通知设备广播信息

DevBroadcastMsg

设备广播信息

public class DevBroadcastMsg {
    private int pid;                 //产品ID
    private int vid;                 //厂商ID
    private int uid;                 //客户ID
    private int deviceType;          //设备类型
    private int version;             //协议版本
    private boolean showDialog;      //弹窗标志
    private String edrAddr;          //设备的经典蓝牙地址
    private int seq;                 //序列号
    private int action;              //行为
    private int leftDeviceQuantity;  //左设备（设备1）电量
    private boolean isLeftCharging;  //左设备（设备1）充电标识
    private int rightDeviceQuantity; //右设备（设备2）电量
    private boolean isRightCharging; //右设备（设备2）充电标识
    private int chargingBinQuantity; //充电仓（设备3）电量
    private boolean isDeviceCharging;//充电仓（设备3）充电标识
}

2.3.14.3 设置设备功能

JL_BluetoothManager方式

命令构造

int type = 0; //功能标识
byte[] data = new byte[0]; //功能参数
byte[] payload = ParseDataUtil.packLTVPacket(type, data);   //参数遵循LTV格式
CommandBase setADVInfoCmd = CommandBuilder.buildSetADVInfoCmd(payload);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//type - 类型
int type = 0;
//value - 数据
byte[] value = new byte[0];
//设置设备功能并等待结果回调
controller.modifyDeviceSettingsInfo(controller.getUsingDevice(), type, value, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //message - 结果码， 0为成功，其他为错误码
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

功能标识	说明	数据格式
0	电量	left(1Byte)+right(1Byte)+charging bin(1Byte), 不可设置电量格式: Bit7 – 是否充电 Bit6-0: 电量
1	设备名称	name(32Bytes), 以’0’结尾
2	按键设置	n * 按键设置按键设置格式: keyID(1Byte)+action(1Byte)+function(1Byte)
3	灯光设置	n * 灯光设置灯光设置格式: scene(1Byte)+effect(1Byte)
4	麦克风设置	mic_channel(1Byte)
5	工作模式	work_mode(1Byte)
6	产品信息	vid(2Bytes)+uid(2Bytes)+pid(2Bytes), 不可设置
7	接入时间	time(4Bytes), 时间戳, 单位是秒
8	入耳检测	state(1Byte), 0 – 未启用, 1 – 关闭, 2 – 打开
9	语言类型	language(n bytes)
10	ANC模式列表	modes(4Bytes), 32位, 表示模式列表序号 Bit0 – 关闭模式, Bit1 – 降噪模式, Bit2 – 通透模式

Important

1. 参数和数据都是 2.3.1.1 LTV格式格式

2. type表示功能标识, 说明数据结构

2.3.14.4 监听设备广播信息

JL_BluetoothManager方式

命令构造

NotifyAdvInfoCmd notifyAdvInfoCmd = (NotifyAdvInfoCmd) command;
NotifyAdvInfoParam advInfoParam = notifyAdvInfoCmd.getParam();

代码示例参考 2.3.3 接收命令处理示例

回复数据参考 NotifyAdvInfoParam

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDeviceBroadcast(BluetoothDevice device, DevBroadcastMsg broadcast) {
        //此处将会回调设备广播信息
    }
});

Note

NotifyAdvInfoParam
DevBroadcastMsg

NotifyAdvInfoParam

public class NotifyAdvInfoParam extends BaseParameter {
    //产品ID
    private int pid;
    //厂商ID
    private int vid;
    //客户ID
    private int uid;
    //设备类型
    private int deviceType;
    //协议版本
    private int version;
    //弹窗标志
    private boolean showDialog;
    //设备的经典蓝牙地址
    private String edrAddr;
    //序列号
    private int seq;
    //行为
    private int action;
    //左设备（设备1）电量
    private int leftDeviceQuantity;
    //左设备（设备1）充电标识
    private boolean isLeftCharging;
    //右设备（设备2）电量
    private int rightDeviceQuantity;
    //右设备（设备2）充电标识
    private boolean isRightCharging;
    //充电仓（设备3）电量
    private int chargingBinQuantity;
    //充电仓（设备3）充电标识
    private boolean isDeviceCharging;
}

2.3.14.5 监听设备请求

JL_BluetoothManager方式

命令构造

RequestAdvOpCmd requestAdvOpCmd = (RequestAdvOpCmd) command;
RequestAdvOpParam opParam = requestAdvOpCmd.getParam();
int op = opParam.getOp();

代码示例参考 2.3.3 接收命令处理示例

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {

    @Override
    public void onTwsStatusChange(BluetoothDevice device, boolean isTwsConnected) {
        //此处将会回调TWS连接状态
    }

    @Override
    public void onDeviceRequestOp(BluetoothDevice device, int op) {
        //此处将会回调设备请求操作
        switch (op) {
            case Constants.ADV_REQUEST_OP_UPDATE_CONFIGURE: //主动更新配置信息
//               controller.getDeviceSettingsInfo(device, 0xffffffff, null);
                break;
            case Constants.ADV_REQUEST_OP_UPDATE_AFTER_REBOOT://更新配置信息，需要重启生效
//               controller.getDeviceSettingsInfo(device, 0xffffffff, new OnRcspActionCallback<ADVInfoResponse>() {
//                   @Override
//                   public void onSuccess(BluetoothDevice device, ADVInfoResponse message) {
//                       controller.rebootDevice(device, null);
//                   }
//
//                   @Override
//                   public void onError(BluetoothDevice device, BaseError error) {
//
//                   }
//               });
                break;
            case Constants.ADV_REQUEST_OP_SYNC_TIME: //请求同步连接时间
//              int connectedTime = (int) (Calendar.getInstance().getTimeInMillis() / 1000);
//              controller.updateConnectedTime(device, connectedTime, null);
                break;
            case Constants.ADV_REQUEST_OP_RECONNECT_DEVICE://请求回连设备
                break;
            case Constants.ADV_REQUEST_OP_SYNC_DEVICE_INFO: //请求同步设备信息
//              controller.requestDeviceInfo(device, 0xffffffff, null);
                break;
            }
        }
});

操作码	说明
0	主动更新配置信息
1	更新配置信息，需要重启生效
2	请求同步接入时间
3	请求回连设备
4	请求同步设备信息

2.3.14.6 更新接入时间

仅RCSPController有接口

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
int connectedTime = (int) (Calendar.getInstance().getTimeInMillis() / 1000); //接入时间
//执行同步接入时间功能并等待结果回调
controller.updateConnectedTime(controller.getUsingDevice(), connectedTime, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //message - 结果码， 0为成功，其他为错误码
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.14.7 设置设备名称

仅RCSPController有接口

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行设置设备名称功能并等待结果回调
controller.configDeviceName(controller.getUsingDevice(), name, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //message - 结果码， 0为成功，其他为错误码
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.14.8 设置按键功能

仅RCSPController有接口

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//按键设置列表，不能为空
List<ADVInfoResponse.KeySettings> keySettingsList = new ArrayList();
//执行设置按键效果功能并等待结果回调
controller.configKeySettings(controller.getUsingDevice(), keySettingsList, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //message - 结果码， 0为成功，其他为错误码
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

按键设置， KeySettings

按键配置

Important

公版的 按键信息 是通过 json文档来获取的。
客户可以动态增加按键功能，只要与固件能对应上即可

以下是 公版的按键信息

按键定义

码值

说明

1

左耳按键

2

右耳按键
动作定义

码值

说明

1

短按耳机

2

轻点两下耳机

功能定义

码值	说明	备注
0	无作用
3	上一曲
4	下一曲
5	播放/暂停
6	接听电话
7	挂断电话
8	回拨电话
9	音量加
10	音量减
11	拍照	部分SDK支持，需要与固件确认
255	ANC模式切换列表	部分SDK支持，需要与固件确认

示例说明

数据: 1, 1, 3, 1, 2, 5, 2, 1, 4, 2, 2, 9

上面数据的意思是：左耳短按时播放上一曲；左耳轻点两下时播放/暂停音乐；右耳短按时播放下一曲；右耳轻点两下时加大音量；

2.3.14.9 设置闪灯效果

仅RCSPController有接口

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//灯效设置列表，不能为空
List<ADVInfoResponse.LedSettings> ledSettingsList = new ArrayList();
//执行设置闪灯效果功能并等待结果回调
controller.configLedSettings(controller.getUsingDevice(), ledSettingsList, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //message - 结果码， 0为成功，其他为错误码
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

灯效设置, LedSettings

灯光配置

Important

公版的 灯光信息 是通过 json文档来获取的。
客户可以动态增加按键功能，只要与固件能对应上即可

以下是 公版的灯光信息

场景定义

码值

说明

1

未配对

2

未连接

3

已连接
效果定义

码值

说明

0

全灭

1

红灯常亮

2

蓝灯常亮

3

红灯呼吸

4

蓝灯呼吸

5

红蓝交替快闪

6

红蓝交替慢闪

示例说明

数据: 1, 0, 2, 6, 3, 2

上面数据的意思是：耳机未配对时，灯光全灭；耳机已配对但未连接时，灯光红蓝交替慢闪；耳机已配对且已连接，灯光蓝灯常亮；

2.3.14.10 更新指定功能

仅RCSPController有接口

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//type - 指定功能
int type = 0;
//value - 值
byte[] value = new byte[0];
//执行更新指定功能的值功能并等待结果回调
controller.updateFunctionValue(controller.getUsingDevice(), type, value, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //message - 结果码， 0为成功，其他为错误码
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.14.11 区分挂脖耳机

未连接时, 通过广播包区分该TWS设备是不是挂脖耳机

/** 设备类型是不是耳机类型(0x02,0x03) :
0x00 -- 音箱类型
0x01 -- 充电仓类型
0x02 -- TWS耳机类型
0x03 -- 耳机类型
0x04--声卡类型
0x05--手表类型 */
boolean isHeadset = UIHelper.isHeadsetByDeviceType(bleScanMessage.getDeviceType());
//广播包版本是不是挂脖版本
boolean isNeck = isHeadset && bleScanMessage.getVersion() == SConstant.ADV_INFO_VERSION_NECK_HEADSET;
return isNeck;

连接时, 通过连接历史记录区分该TWS设备是不是挂脖耳机

/** 芯片类型是不是耳机类型(2,4):
0:AI SDK (692X_AI智能音箱SDK)
1:ST SDK (692X_标准音箱SDK)
2:693x_TWS SDK
3:695xSDK
4:697x_TWS SDK
5:696x_soundbox
6:696x_tws
7:695x_sound_card
8:695x_sound_watch
9:701x_sound_watch */
boolean isHeadsetType = history != null && UIHelper.isHeadsetType(history.getChipType());
//广播包版本是不是挂脖版本
boolean isNeck = isHeadsetType && history.getAdvVersion() == SConstant.ADV_INFO_VERSION_NECK_HEADSET;
return isNeck;

2.3.14.12 辅听耳机的验配功能

验配信息交互：版本、通道数、通道频率

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//验配信息交互：版本、通道数、通道频率
controller.getHearingAssistInfo(controller.getUsingDevice(), new OnRcspActionCallback<HearingAssistInfo>() {
    @Override
    public void onSuccess(BluetoothDevice device, HearingAssistInfo message) {
        //成功回调
        //message - 辅听验配信息
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

通道验配

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//通道验配
controller.setHearingAssistFrequency(controller.getUsingDevice(), hearingFrequencyInfo, new OnRcspActionCallback<Boolean>() {

    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //message - 执行是否成功
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

验配结果保存更新

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//验配结果保存更新
controller.setHearingAssistFrequencies(controller.getUsingDevice(), hearingFrequenciesInfo, new OnRcspActionCallback<Boolean>() {

    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //message - 执行是否成功
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

停止验配

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//停止验配
controller.stopHearingAssistFitting(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {

    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //message - 执行是否成功
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

监听辅听验配相关信息

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//监听辅听验配相关信息
BTRcspEventCallback mBTRcspEventCallback = new BTRcspEventCallback() {
    //监听验配信息交互：版本、通道数、通道频率
    @Override
    public void onHearingAssistInfo(BluetoothDevice device, HearingAssistInfo hearingAssistInfo) {
        super.onHearingAssistInfo(device, hearingAssistInfo);
        //hearingAssistInfo - 验配信息交互
    }

    //监听设备验配音频开关状态
    @Override
    public void onHearingChannelsStatus(BluetoothDevice device, HearingChannelsStatus hearingChannelsStatus) {
        super.onHearingChannelsStatus(device, hearingChannelsStatus);
        //hearingChannelsStatus - 辅听声道开关状态
    }
};
controller.addBTRcspEventCallback(mBTRcspEventCallback);

2.3.15 ANC设置功能

2.3.15.1 流程图

2.3.15.2 获取所有噪声处理信息

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_ALL_NOISE_MODE – 所有噪声处理信息

命令构造

CommandBase getAllVoiceModesCmd = CommandBuilder.buildGetAllVoiceModes();

代码示例参考 2.3.5.2 查询设备系统信息回复结果参考 VoiceMode

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onVoiceModeList(BluetoothDevice device, List<VoiceMode> voiceModes) {
        //此处将会回调噪声处理信息列表
    }
});
//执行获取所有噪声处理信息功能并等待结果回调
controller.getAllVoiceModes(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //数据将在BTRcspEventCallback#onVoiceModeList回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

噪声处理模式，VoiceMode

VoiceMode

噪声处理模式

public class VoiceMode implements Parcelable {
    private int mode = -1;     //ANC模式
    private int leftMax;       //左声道最大值
    private int leftCurVal;    //左声道当前值
    private int rightMax;      //右声道最大值
    private int rightCurVal;   //右声道当前值

    //标准模式
    public final static int VOICE_MODE_CLOSE = 0;
    //降噪模式
    public final static int VOICE_MODE_DENOISE = 1;
    //通透模式
    public final static int VOICE_MODE_TRANSPARENT = 2;

}

2.3.15.3 获取当前噪声处理模式

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_CURRENT_NOISE_MODE – 当前噪声处理模式

命令构造

CommandBase getCurrentVoiceModeCmd = CommandBuilder.buildGetCurrentVoiceMode();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onCurrentVoiceMode(BluetoothDevice device, VoiceMode voiceMode) {
        //此处将会回调当前噪声处理模式信息
    }
});
//执行获取当前噪声处理模式信息功能并等待结果回调
controller.getCurrentVoiceMode(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //数据将在BTRcspEventCallback#onCurrentVoiceMode回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

噪声处理模式，VoiceMode

2.3.15.4 设置当前噪声处理模式

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC    – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_LIGHT             – 灯光控制
value :  data(n Bytes)                                     – 控制数据

命令构造

VoiceMode voiceMode;
CommandBase setCurrentVoiceModeCmd = CommandBuilder.buildSetCurrentVoiceMode(voiceMode);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
VoiceMode voiceMode; //voiceMode - 噪声处理模式
//执行设置当前噪声处理模式功能并等待结果回调
controller.setCurrentVoiceMode(controller.getUsingDevice(), voiceMode, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

噪声处理模式，VoiceMode

2.3.15.5 设置切换噪声处理模式顺序

JL_BluetoothManager方式

//噪声模式切换不能小于2个
if (modes == null || modes.length < 2) return;
//设置模式切换顺序
int value = 0x00;
for (int mode : modes) {
    byte bit = (byte) (mode & 0xff);
    value = value | (0x01 << bit);
}
int function = AttrAndFunCode.ADV_TYPE_ANC_MODE_LIST; //ANC噪声处理功能码
byte[] data = CHexConver.intToBigBytes(value);     //功能数据

代码示例参考 2.3.14.3 设置设备功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//噪声模式切换不能小于2个
if (modes == null || modes.length < 2) return;
//设置模式切换顺序
int value = 0x00;
for (int mode : modes) {
    byte bit = (byte) (mode & 0xff);
    value = value | (0x01 << bit);
}
//执行设置模式切换顺序功能并等待结果回调
controller.modifyDeviceSettingsInfo(controller.getUsingDevice(), AttrAndFunCode.ADV_TYPE_ANC_MODE_LIST, CHexConver.intToBigBytes(value), new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
        //成功之后，可以获取结果
        controller.getDeviceSettingsInfo(device, 0x01 << AttrAndFunCode.ADV_TYPE_ANC_MODE_LIST, new OnRcspActionCallback<ADVInfoResponse>() {
            @Override
            public void onSuccess(BluetoothDevice device, ADVInfoResponse message) {
//              message.getModes();//噪声模式切换顺序
            }

            @Override
            public void onError(BluetoothDevice device, BaseError error) {
                //失败回调
                //error - 错误信息
            }
        });
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

ADVInfoResponse

2.3.15.6 按键设置切换噪声处理模式顺序

JL_BluetoothManager方式

List<ADVInfoResponse.KeySettings> list = new ArrayList<>(); //获取设备设置信息得到
list.get(0).setFunction(AttrAndFunCode.KEY_FUNC_ID_SWITCH_ANC_MODE); //anc
int function = AttrAndFunCode.ADV_TYPE_KEY_SETTINGS; //按键设置功能码
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
for (ADVInfoResponse.KeySettings settings : list) {
    try {
        outputStream.write(settings.toData());
    } catch (IOException e) {
        e.printStackTrace();
    }
}
byte[] data = outputStream.toByteArray();     //功能数据

代码示例参考 2.3.14.3 设置设备功能

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
List<ADVInfoResponse.KeySettings> list = new ArrayList<>(); //获取设备设置信息得到
list.get(0).setFunction(AttrAndFunCode.KEY_FUNC_ID_SWITCH_ANC_MODE); //anc
//设置按键功能切换ANC设置功能并等待结果回调
controller.configKeySettings(controller.getUsingDevice(), list, new OnRcspActionCallback<Integer>() {
    @Override
    public void onSuccess(BluetoothDevice device, Integer message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Important

切换噪声处理模式的按键功能ID固定是 255

2.3.16 声卡功能

Important

声卡功能需要与固件工程师协商功能序号

2.3.16.1 获取声卡功能状态

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : 0x01 << AttrAndFunCode.SYS_INFO_ATTR_SOUND_CARD – 声卡功能

命令构造

CommandBase getSoundCardStatusInfoCmd = CommandBuilder.buildGetSoundCardStatusInfo();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onSoundCardStatusChange(BluetoothDevice device, long mask, byte[] values) {
        //此处将会回调声卡状态
    }
});
//执行获取声卡状态信息功能并等待结果回调
controller.getSoundCardStatusInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onSoundCardStatusChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.16.2 获取声卡效果参数

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : – 声卡效果 * 0x01 << AttrAndFunCode.SYS_INFO_ATTR_SOUND_CARD_EQ_FREQ * 0x01 << AttrAndFunCode.SYS_INFO_ATTR_SOUND_CARD_EQ_GAIN

命令构造

CommandBase getSoundCardEqInfoCmd = CommandBuilder.buildGetSoundCardEqInfo();

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onSoundCardEqChange(BluetoothDevice device, EqInfo eqInfo) {
        //此处将会回调声卡效果信息
    }
});
//执行获取声卡效果信息功能并等待结果回调
controller.getSoundCardEqInfo(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //结果将会在BTRcspEventCallback#onSoundCardEqChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

2.3.8.3 EqInfo

2.3.16.3 设置声卡功能

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC   – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_SOUND_CARD       – 声卡功能
value :  index(1Byte)+value(2Bytes)

命令构造

int index = 0;  //功能序号
int value = 2;  //功能值
CommandBase setSoundCardInfoCmd = CommandBuilder.buildSetSoundCardInfo((byte)index, value);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//index --- 索引
int index = 0;
//value --- 数值
byte[] value = new byte[0];
//设置声卡功能并等待结果回调
controller.setSoundCardFunction(controller.getUsingDevice(), index, value, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.16.4 设置声卡效果

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC         – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_SOUND_CARD_EQ_GAIN     – 声卡效果
value :  len(1Byte)+payload(n Bytes)

命令构造

byte[] data = new byte[2];
data[0] = 2;  //len
data[1] = 1;  //payload
CommandBase setSoundCardEqValueCmd = CommandBuilder.buildSetSoundCardEqValue(data);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行设置声卡效果功能并等待结果回调
controller.setSoundCardEqInfo(controller.getUsingDevice(), value, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.16.5 配置文档

config.json

{
    "hasEq": "true",
    "function": [
    {
        "id": 0,
        "title": {
        "zh": "变声",
        "en": "Voice"
        },
        "type": "select",
        "icon_url": "icon_voice_nol.png",
        "column": 3,
        "paging": false,
        "list": [
        {
            "title": {
            "zh": "正常",
            "en": "Normal"
            },
            "index": 0
        },
        {
            "title": {
            "zh": "男声",
            "en": "Boy"
            },
            "index": 1
        },
        {
            "title": {
            "zh": "女声",
            "en": "Girl"
            },
            "index": 2
        },
        {
            "title": {
            "zh": "童音",
            "en": "Children"
            },
            "index": 3
        },
        {
            "title": {
            "zh": "魔音",
            "en": "Magic"
            },
            "index": 4
        },
        {
            "title": {
            "zh": "电音",
            "en": "EM"
            },
            "group": true,
            "list": [
            {
                "title": {
                "zh": "A大调",
                "en": "A major"
                },
                "index": 5
            },
            {
                "title": {
                "zh": "升A大调",
                "en": "L A major"
                },
                "index": 6
            },
            {
                "title": {
                "zh": "B大调",
                "en": "B major"
                },
                "index": 7
            },
            {
                "title": {
                "zh": "C大调",
                "en": "C major"
                },
            "index": 8
            },
            {
                "title": {
                "zh": "升C大调",
                "en": "L C major"
                },
            "index": 9
            },
            {
                "title": {
                "zh": "D大调",
                "en": "D major"
                },
                "index": 10
            },
            {
                "title": {
                "zh": "升D大调",
                "en": "L D major"
                },
                "index": 11
            },
            {
                "title": {
                "zh": "E大调",
                "en": "E major"
                },
                "index": 12
            },
            {
                "title": {
                "zh": "F大调",
                "en": "F major"
                },
                "index": 13
            },
            {
                "title": {
                "zh": "升F大调",
                "en": "L F major"
                },
                "index": 14
            },
            {
                "title": {
                "zh": "G大调",
                "en": "G major"
                },
                "index": 15
            },
            {
                "title": {
                "zh": "升G大调",
                "en": "L G major"
                },
                "index": 16
            }
          ]
        }
      ]
    },
    {
        "title": {
        "zh": "其他",
        "en": "Other"
        },
        "id": 3,
        "icon_url": "icon_others_nol.png",
        "type": "select",
        "column": 3,
        "paging": false,
        "list": [
        {
            "title": {
            "zh": "爆音",
            "en": "Popping"
            },
            "index": 36
        },
        {
            "title": {
            "zh": "喊麦",
            "en": "Shout"
            },
            "index": 37
        },
        {
            "title": {
            "zh": "闪避",
            "en": "Dodge"
            },
            "index": 38
        }
      ]
    },
    {
        "title": {
        "zh": "气氛",
        "en": "AtmosPhere"
        },
        "id": "1",
        "icon_url": "icon_effect_nol.png",
        "type": "img_select",
        "column": 4,
        "paging": true,
        "row": 2,
        "list": [
        {
            "title": {
            "zh": "欢呼",
            "en": "Cheers"
            },
            "index": 17,
            "icon_url": "img_cheer.png"
        },
        {
            "title": {
            "zh": "尴尬",
            "en": "Awkward"
            },
            "index": 18,
            "icon_url": "img_awkward.png"
        },
        {
            "title": {
            "zh": "枪声",
            "en": "Gunfire"
            },
            "index": 19,
            "icon_url": "img_gun.png"
        },
        {
            "title": {
            "zh": "鄙视",
            "en": "Despise"
            },
            "index": 20,
            "icon_url": "img_despise.png"
        },
        {
            "title": {
            "zh": "开场",
            "en": "Stage"
            },
            "index": 21,
            "icon_url": "img_stage.png"
        },
        {
            "title": {
            "zh": "飞吻",
            "en": "Kiss"
            },
            "index": 22,
            "icon_url": "img_kiss.png"
        },
        {
            "title": {
            "zh": "笑声",
            "en": "Laugh"
            },
            "index": 23,
            "icon_url": "img_laugh.png"
        },
        {
            "title": {
            "zh": "掌声",
            "en": "Applause"
            },
            "index": 24,
            "icon_url": "img_applause.png"
        },
        {
            "title": {
            "zh": "请关注",
            "en": "Attention"
            },
            "index": 25,
            "icon_url": "img_follow.png"
        },
        {
            "title": {
            "zh": "么么哒",
            "en": "Mua"
            },
            "index": 26,
            "icon_url": "img_memeda.png"
        },
        {
            "title": {
             "zh": "贼啦啦",
            "en": "Song01"
            },
            "index": 27,
            "icon_url": "img_song_01.png"
        },
        {
            "title": {
            "zh": "非诚勿扰",
            "en": "Song02"
            },
            "index": 28,
            "icon_url": "img_song_02.png"
        }
      ]
    },
    {
        "title": {
        "zh": "Mic参数",
        "en": "Mic Args"
        },
        "id": 2,
        "icon_url": "icon_settle_nol.png",
        "type": "slider",
        "list": [
         {
            "title": {
            "zh": "麦音量",
            "en": "Mic Vol"
            },
            "index": 29,
            "max": 30,
            "enable": true
        },
        {
            "title": {
            "zh": "录音音量",
            "en": "Record Vol"
            },
            "index": 30,
            "enable": true,
            "max": 30
        },
        {
            "title": {
            "zh": "混响",
            "en": "Reverberation"
            },
            "index": 31,
            "enable": true,
            "max": 30
        },
        {
            "title": {
            "zh": "高音",
            "en": "High"
            },
            "index": 32,
            "enable": true,
            "max": 10
        },
        {
            "title": {
            "zh": "低音",
            "en": "Bass"
            },
            "index": 33,
            "enable": true,
            "max": 10
        },
        {
            "title": {
            "zh": "伴奏音量",
            "en": "Accomp Vol"
            },
            "index": 34,
            "enable": true,
            "max": 30
        },
        {
            "title": {
            "zh": "监听音量",
            "en": "Monitor Vol"
            },
            "index": 35,
            "enable": true,
            "max": 30
        }
      ]
    }
  ]
}

字段说明

字段	描述
id	区分分类
title	标题
icon_url	项目图标链接
type	子项的控件类型：目前支持： img_select(可以设置图片),select,slider
column	控件列数，当type==slider,无效
row	控件行数，需要结合colume使用且paging==true有效
paging	控件的唯一表示码，全局唯一， group为true时,index无效
max	最大值, type==slider时有效
group	是否组类型, true则没有index字段,当type为select有效
enable	slider类型有效, true:app可以调节, false:app不可已调节

2.3.17 查找设备功能

2.3.17.1 查找设备

JL_BluetoothManager方式

命令构造

int type = 1;         //查找类型 ： 0 --- 查找手机  1 --- 查找设备
int op = 1;           //铃声操作 ： 0 --- 关闭铃声  1 --- 播放铃声
int timeoutSec = 60;  //超时时间 ： 0 --- 不限制时间
int playWay = 0;      //播放方式： 0 -- 全部播放 1 -- 左侧播放 2 -- 右侧播放
int player = 0;       //播放源: 0 -- App端播放 1 -- 设备端播放
CommandBase searchDevCmd = CommandBuilder.buildSearchDevCmd(op, timeoutSec, playWay, player);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//way : 0 -- all  1 -- left  2 -- right
//执行搜索设备功能并等待结果回调
controller.searchDev(controller.getUsingDevice(), Constants.RING_OP_OPEN, 60, way, Constants.RING_PLAYER_APP, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.17.2 停止查找设备

JL_BluetoothManager方式

命令构造

int type = 1;         //查找类型 ： 0 --- 查找手机  1 --- 查找设备
int op = 0;           //铃声操作 ： 0 --- 关闭铃声  1 --- 播放铃声
int timeoutSec = 0;   //超时时间 ： 0 --- 不限制时间
int playWay = 0;      //播放方式： 0 -- 全部播放 1 -- 左侧播放 2 -- 右侧播放
int player = 0;       //播放源: 0 -- App端播放 1 -- 设备端播放
CommandBase stopSearchDevCmd = CommandBuilder.buildSearchDevCmd(op, timeoutSec, playWay, player);

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//执行停止搜索设备功能并等待结果回调
controller.stopSearchDevice(controller.getUsingDevice(), new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.17.3 查找手机

JL_BluetoothManager方式

命令构造

SearchDevCmd searchDevCmd = (SearchDevCmd) command;
SearchDevParam param = searchDevCmd.getParam();
param.getType();         //查找类型 ： 0 --- 查找手机  1 --- 查找设备
param.getOp();           //铃声操作 ： 0 --- 关闭铃声  1 --- 播放铃声
param.getTimeoutSec();   //超时时间 ： 0 --- 不限制时间
param.getWay();          //播放方式： 0 -- 全部播放 1 -- 左侧播放 2 -- 右侧播放
param.getPlayer();       //播放源: 0 -- App端播放 1 -- 设备端播放

代码示例参考 2.3.3 接收命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onSearchDevice(BluetoothDevice device, SearchDevParam searchDevParam) {
        if (searchDevParam.getOp() == Constants.RING_OP_OPEN) { //open ring
            int timeout = searchDevParam.getTimeoutSec();//timeout, unit : second
            int player = searchDevParam.getPlayer(); //player (0 --- app play ring  1 --- device play ring)
        } else {
            //close ring
        }
    }
});

2.3.17.4 同步查找设备状态

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
final JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//获取已连接和正在使用的设备
final BluetoothDevice device = manager.getConnectedDevice();
//Step1: 构建命令 --- 查询查找设备状态
CommandBase searchDevStatus = CommandBuilder.buildSearchDevStatusCmd();
//Step2: 执行查询查找设备状态功能并等待结果回调
manager.sendRcspCommand(device, searchDevStatus, new RcspCommandCallback() {
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        SearchDevCmd searchDevCmd = (SearchDevCmd) cmd;
        SearchDevStatusResponse response = (SearchDevStatusResponse) searchDevCmd.getResponse();
        //response -- 查询设备状态
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//获取已连接和正在使用的设备
final BluetoothDevice device = controller.getUsingDevice();
//执行同步查找设备状态功能并等待回调
controller.syncSearchDeviceStatus(device, new OnRcspActionCallback<SearchDevStatusResponse>() {
    @Override
    public void onSuccess(BluetoothDevice device, SearchDevStatusResponse message) {
        //成功回调
        //message -- 查询设备状态
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

SearchDevStatusResponse

SearchDevStatusResponse

查找设备状态

public class SearchDevStatusResponse {
    private int op;       //操作
    private int timeout;  //超时
    private int way;      //方式
    private int player;   //播放来源
}

2.3.18 自定义命令

2.3.18.1 发送自定义命令

JL_BluetoothManager方式

命令构造

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 构造自定义命令
byte[] data = new byte[20]; //自定义数据
CommandBase customCmd = CommandBuilder.buildCustomCmd(data);
//Step2: 执行操作命令并等待结果回调
manager.sendCommandAsync(manager.getConnectedDevice(), customCmd, manager.getBluetoothOption().getTimeoutMs(), new RcspCommandCallback() {
    //回调回复命令
    //注意: 无回复命时，回复命令本身
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        //成功回调
        //Step4: 获取对应的命令数据
        CustomCmd customCmd = (CustomCmd) cmd;
        //Step5: 获取回复数据
        CustomResponse response = customCmd.getResponse();
        if (null == response) { return;}
        byte[] data = response.getData(); //自定义回复数据
        //处理设备回复数据
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

代码示例参考 2.3.2 通用命令处理示例

RCSPController方式

//获取RCSPController对象
RCSPController controller = RCSPController.getInstance();
//创建自定义命令
CommandBase customCmd = CommandBuilder.buildCustomCmd(data);
//发送自定义命令并等待结果回调
controller.sendRcspCommand(controller.getUsingDevice(), customCmd, new RcspCommandCallback() {
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //固件回复失败状态
            BaseError error = new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device response an bad status : " + cmd.getStatus());
            error.setOpCode(Command.CMD_EXTRA_CUSTOM);
            onErrCode(device, error);
            return;
        }
        //发送成功回调, 需要回复设备
        CustomCmd customCmd = (CustomCmd) cmd;
        byte[] responseData = new byte[0]; //可以设置回复的数据
        customCmd.setParam(new CustomParam(responseData));
        customCmd.setStatus(StateCode.STATUS_SUCCESS);
        controller.sendRcspResponse(device, customCmd); //发送命令回复
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

发送自定义数据需要符合 RCSP协议 的最大值规则，数据量不能超过(最大值 - 20)

//获取当前操作设备
BluetoothDevice device = RCSPController.getInstance().getUsingDevice();
//获取SDK端最大发送值（即设备端的最大接收值）
int max = DeviceStatusManager.getInstance().getMaxReceiveMtu(device);
//计算自定义数据最大长度
int size = max - 20;

2.3.18.2 接收自定义命令

JL_BluetoothManager方式

命令构造

CustomCmd customCmd = (CustomCmd) cmd;
CustomParam param = customCmd.getParam();
boolean isNeedResponse = cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE || cmd.getType() == CommandBase.FLAG_NO_PARAMETER_AND_RESPONSE;
if(null == param){
    if(isNeedResponse){ //需要回复
        byte[] responseData = new byte[0]; //可以设置回复的数据
        customCmd.setParam(new CustomParam(responseData));
        customCmd.setStatus(StateCode.STATUS_SUCCESS);
        manager.sendCommandResponse(device, customCmd); //发送命令回复
    }
    return;
}
byte[] data = param.getData(); //自定义数据
//parseCustomData(data);
if(isNeedResponse){ //需要回复
    byte[] responseData = new byte[0]; //可以设置回复的数据
    customCmd.setParam(new CustomParam(responseData));
    customCmd.setStatus(StateCode.STATUS_SUCCESS);
    manager.sendCommandResponse(device, customCmd); //发送命令回复
}

代码示例参考 2.3.3 接收命令处理示例

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDeviceCommand(BluetoothDevice device, CommandBase cmd) {
        //此处将回调设备发送的命令
        if (cmd.getId() == Command.CMD_EXTRA_CUSTOM) { //只处理自定义命令数据
            CustomCmd customCmd = (CustomCmd) cmd;
            CustomParam param = customCmd.getParam();
            if(null == param){
                if(cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE){ //需要回复
                    byte[] responseData = new byte[0]; //可以设置回复的数据
                    customCmd.setParam(new CustomParam(responseData));
                    customCmd.setStatus(StateCode.STATUS_SUCCESS);
                    controller.sendRcspResponse(device, customCmd); //发送命令回复
                }
                return;
            }
            byte[] data = param.getData(); //自定义数据
            //parseCustomData(data);
            if(cmd.getType() == CommandBase.FLAG_HAVE_PARAMETER_AND_RESPONSE){ //需要回复
                byte[] responseData = new byte[0]; //可以设置回复的数据
                customCmd.setParam(new CustomParam(responseData));
                customCmd.setStatus(StateCode.STATUS_SUCCESS);
                controller.sendRcspResponse(device, customCmd); //发送命令回复
            }
        }
    }
});

2.3.19 设备双连功能

2.3.19.1 查询是否支持设备双连功能

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 获取设备信息
final BluetoothDevice device = manager.getConnectedDevice();
DeviceInfo deviceInfo = manager.getDeviceInfo(device);
//Step2: 查询是否支持设备双连功能
boolean isSupportDoubleConnection = deviceInfo != null && deviceInfo.isSupportDoubleConnection();

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//查询是否支持设备双连功能
final BluetoothDevice device = controller.getUsingDevice();
boolean isSupportDoubleConnection = controller.isSupportDoubleConnection(device);

2.3.19.2 获取设备双连状态

Note

设备必须支持【设备双连】功能才能使用

JL_BluetoothManager方式

function : AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC – 公共属性

mask : – 设备双连状态 * 0x00000001 << AttrAndFunCode.SYS_INFO_ATTR_DOUBLE_CONNECT

命令构造

CommandBase getDoubleConnectionStateCmd = CommandBuilder.buildGetSysInfoCmd(AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC,
            0x00000001 << AttrAndFunCode.SYS_INFO_ATTR_DOUBLE_CONNECT);

代码示例参考 2.3.5.2 查询设备系统信息

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDoubleConnectionChange(BluetoothDevice device, DoubleConnectionState state) {
        //回调设备双连状态
    }
});
//执行查询设备双连状态功能并等待结果回调
final BluetoothDevice device = controller.getUsingDevice();
controller.queryDoubleConnectionState(device, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //信息将在BTRcspEventCallback#onDoubleConnectionChange回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

设备双连状态, DoubleConnectionState

DoubleConnectionState

设备双连状态

public class DoubleConnectionState implements Parcelable {
    private int version = 0;  //版本号
    private boolean isOn;     //是否开启
    private String btAddress; //连接设备的蓝牙地址
}

2.3.19.3 设置设备双连开关

Note

设备必须支持【设备双连】功能才能使用

JL_BluetoothManager方式

function :  AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC  – 公共属性
type :  AttrAndFunCode.SYS_INFO_ATTR_DOUBLE_CONNECT  – 标识设备双连功能
value : DoubleConnectionState (n Bytes) –

命令构造

//Step0: 获取JL_BluetoothManager对象
final JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
final BluetoothDevice device = manager.getConnectedDevice();
//需要先调用【获取设备双连状态】功能获取，后通过缓存信息获取
final DoubleConnectionState state = manager.getDeviceInfo(device).getDoubleConnectionState();
state.setOn(true);//设置开关
//构建设置设备双连状态命令
List<AttrBean> list = new ArrayList<>();
AttrBean attrBean = new AttrBean();
attrBean.setType(AttrAndFunCode.SYS_INFO_ATTR_DOUBLE_CONNECT);
attrBean.setAttrData(state.toData());
list.add(attrBean);
CommandBase setDoubleConnectionStateCmd = CommandBuilder.buildSetSysInfoCmd(AttrAndFunCode.SYS_INFO_FUNCTION_PUBLIC, list);

代码示例参考 2.3.5.3 设置设备系统属性

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onDoubleConnectionChange(BluetoothDevice device, DoubleConnectionState state) {
        //回调设备双连状态
    }
});
//执行设置设备双连状态功能并等待结果回调
final BluetoothDevice device = controller.getUsingDevice();
final DoubleConnectionState state = controller.getDeviceInfo(device).getDoubleConnectionState();
state.setOn(true);//设置开关
controller.setDoubleConnectionState(device, state, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //成功回调
        //可以等设备推送信息，也可以主动查询
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

2.3.19.4 获取已连接设备的设备信息

Note

设备必须支持【设备双连】功能才能使用

JL_BluetoothManager方式

//Step0: 获取JL_BluetoothManager对象
final JL_BluetoothManager manager = JL_BluetoothManager.getInstance(context);
//Step1: 获取当前正在使用的设备
final BluetoothDevice device = manager.getConnectedDevice();
if (null == device) return;
//Step2: 执行查询已连接设备的手机信息功能的值功能并等待结果回调
DeviceBtInfo deviceBtInfo = DoubleConnectionSp.getInstance().getDeviceBtInfo(device.getAddress());
if (null == deviceBtInfo) {
    String btName = AppUtil.getBtName(MainApplication.getApplication());
    deviceBtInfo = new DeviceBtInfo().setBtName(btName);
}
CommandBase queryConnectedPhoneBtInfoCmd = CommandBuilder.buildQueryConnectedPhoneBtInfoCmd(deviceBtInfo);
manager.sendRcspCommand(device, queryConnectedPhoneBtInfoCmd, new RcspCommandCallback() {
    @Override
    public void onCommandResponse(BluetoothDevice device, CommandBase cmd) {
        //Step3: 检查设备状态
        if (cmd.getStatus() != StateCode.STATUS_SUCCESS) { //设备状态异常，进行异常处理
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_RESPONSE_BAD_STATUS, "Device reply an bad status: " + cmd.getStatus()));
            return;
        }
        QueryPhoneBtInfoCmd queryPhoneBtInfoCmd = (QueryPhoneBtInfoCmd) cmd;
        QueryPhoneBtInfoCmd.Response resp = queryPhoneBtInfoCmd.getResponse();
        if(null == resp){
            onErrCode(device, new BaseError(ErrorCode.SUB_ERR_DATA_FORMAT, "Device reply is error."));
            return;
        }
        //解析数据
    }

    @Override
    public void onErrCode(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

RCSPController方式

//获取RCSPController对象
final RCSPController controller = RCSPController.getInstance();
//注册蓝牙RCSP事件监听器
controller.addBTRcspEventCallback(new BTRcspEventCallback() {
    @Override
    public void onConnectedBtInfo(BluetoothDevice device, ConnectedBtInfo info) {
        //回调已连接设备的手机信息
    }
});
//执行查询已连接设备的手机信息功能并等待结果回调
final BluetoothDevice device = controller.getUsingDevice();
//查询数据库保存的本地信息
DeviceBtInfo deviceBtInfo = DoubleConnectionSp.getInstance().getDeviceBtInfo(device.getAddress());
if (null == deviceBtInfo) {
    String btName = AppUtil.getBtName(MainApplication.getApplication());
    deviceBtInfo = new DeviceBtInfo().setBtName(btName);
}
controller.queryConnectedPhoneBtInfo(device, deviceBtInfo, new OnRcspActionCallback<ConnectedBtInfo>() {
    @Override
    public void onSuccess(BluetoothDevice device, ConnectedBtInfo message) {
        //成功回调
        //信息将在BTRcspEventCallback#onConnectedBtInfo回调
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //失败回调
        //error - 错误信息
    }
});

Note

设备已连接的手机蓝牙信息, ConnectedBtInfo

ConnectedBtInfo

设备已连接的手机蓝牙信息

public class ConnectedBtInfo implements Parcelable {
    private int connectionNum;  //已连接设备的数量
    private List<DeviceBtInfo> mDeviceBtInfoList; //已连接的设备的蓝牙信息
}

DeviceBtInfo

设备蓝牙信息

public class DeviceBtInfo implements Parcelable {
    private boolean isBind; //是否本机绑定
    private String address; //设备蓝牙地址
    private String btName;  //设备蓝牙名称
}

2.3.20 录音功能

2.3.20.1 初始化和监听录音事件

//获取录音功能操作对象
mRecordOp = RecordOpImpl.getInstance(RCSPController.getInstance().getRcspOp());
//录音事件回调
final OnRecordStateCallback recordStateCallback = (device, state) -> {
    switch (state.getState()) {
        case RecordState.RECORD_STATE_IDLE:  //空闲或者结束
            int reason = state.getReason();  //结束原因
            if (reason == RecordState.REASON_NORMAL) { //录音完成
                byte[] voiceData = state.getVoiceData(); //录音全部数据
            } else { //录音失败，错误码

            }
            break;
        case RecordState.RECORD_STATE_START: //开始录音
            RecordParam param = state.getRecordParam(); //录音参数
            //param.getVoiceType(); //数据格式
            //param.getSampleRate(); //采样率
            //param.getVadWay();   //断句方
            break;
        case RecordState.RECORD_STATE_WORKING: //正在录音
            RecordParam recordParam = state.getRecordParam(); //录音参数
            byte[] data = state.getVoiceDataBlock(); //录音数据
            break;
    }
};
//注册录音事件回调
mRecordOp.addOnRecordStateCallback(recordStateCallback);

//退出界面，或者不需要监听回调，记得移除回调。
//mRecordOp.removeOnRecordStateCallback(recordStateCallback);

Note

录音状态, RecordState
设备主动请求开始录音时，SDK会回调对应状态，用户需要做好状态处理
注册和移除回调，关联使用。重复注册，会造成事件重复回调。

RecordState

录音状态

public class RecordState {
     /**
      * 录音状态 -- 空闲状态
      */
     public static final int RECORD_STATE_IDLE = 0;
     /**
      * 录音状态 -- 开始状态
      */
     public static final int RECORD_STATE_START = 1;
     /**
      * 录音状态 -- 工作状态
      */
     public static final int RECORD_STATE_WORKING = 2;

     /**
      * 正常结束
      */
     public static final int REASON_NORMAL = 0;
     /**
      * 主动结束
      */
     public static final int REASON_STOP = 1;

     /**
      * 状态
      */
     private int state = RECORD_STATE_IDLE;
     /**
      * 录音参数
      */
     private RecordParam recordParam;
     /**
      * 音频内容块
      */
     private byte[] voiceDataBlock;
     /**
      * 结束原因
      */
     private int reason = REASON_NORMAL;
     /**
      * 音频内容
      */
     private byte[] voiceData;
     /**
      * 错误描述
      */
     private String message;
 }

2.3.20.2 开始录音

用户主动开始录音

if (null == mRecordOp) {
    System.out.println("还没有初始化！！！");
    return;
}
BluetoothDevice device = RCSPController.getInstance().getUsingDevice();
if(mRecordOp.isRecording(device)){
    System.out.println("正在录音中");
    return;
}
//录音参数
//voiceType --- 数据格式
//sampleRate --- 采样率
//vadWay --- 断句方
RecordParam param = new RecordParam(RecordParam.VOICE_TYPE_OPUS, RecordParam.SAMPLE_RATE_16K, RecordParam.VAD_WAY_DEVICE);
//执行录音功能
mRecordOp.startRecord(device, param, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //回调操作成功
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //回调操作失败
        //error --- 错误信息
    }
});

2.3.20.3 停止录音

用户主动停止录音

if (null == mRecordOp) {
    System.out.println("还没有初始化！！！");
    return;
}
mRecordOp.stopRecord(RCSPController.getInstance().getUsingDevice(), RecordState.REASON_NORMAL, new OnRcspActionCallback<Boolean>() {
    @Override
    public void onSuccess(BluetoothDevice device, Boolean message) {
        //回调操作成功
    }

    @Override
    public void onError(BluetoothDevice device, BaseError error) {
        //回调操作失败
        //error --- 错误信息
    }
});

2.3.20.4 释放资源

不再使用时，需要释放对象

if(null == mRecordOp) return;
mRecordOp.destroy();
mRecordOp = null;

2.3.21 SPDIF功能

控制设备端SPDIF功能：播放状态以及音源切换，如 HDMI /光纤/同轴等切换。

获取缓存的SPDIF状态信息(播放状态+音源)

RCSPController mRCSPController = RCSPController.getInstance();
DeviceInfo deviceInfo = mRCSPController.getDeviceInfo();
SPDIFPlayStatusInfo spdifPlayStatusInfo = deviceInfo.getSPDIFPlayStatusInfo();//播放状态
SPDIFAudioSourceInfo spdifAudioSourceInfo = deviceInfo.getSPDIFAudioSourceInfo();//音源

监听SPDIF状态信息(播放状态+音源)

private final BTRcspEventCallback callback = new BTRcspEventCallback() {
    @Override
    public void onSPDIFPlayStatusChange(BluetoothDevice device, SPDIFPlayStatusInfo spdifPlayStatusInfo) {//播放状态
    }

    @Override
    public void onSPDIFAudioSourceInfoChange(BluetoothDevice device, SPDIFAudioSourceInfo spdifAudioSourceInfo) {//音源
    }
};
RCSPController mRCSPController = RCSPController.getInstance();
mRCSPController.addBTRcspEventCallback(callback);

实时获取SPDIF状态信息(播放状态+音源)。状态信息结果通过监听SPDIF状态信息回调。

RCSPController mRCSPController = RCSPController.getInstance();
mRCSPController.getSPDIFInfo(mRCSPController.getUsingDevice(), null);

设置播放状态

RCSPController mRCSPController = RCSPController.getInstance();
SPDIFPlayStatusInfo spdifPlayStatusInfo = new SPDIFPlayStatusInfo();
spdifPlayStatusInfo.setPlayStatus( SPDIFPlayStatusInfo.PLAY_STATUS_PLAY);//设置播放状态 -- 播放
mRCSPController.setSPDIFPlayStatusInfo(getConnectedDevice(), spdifPlayStatusInfo, null);

设置音源

RCSPController mRCSPController = RCSPController.getInstance();
SPDIFAudioSourceInfo spdifAudioSourceInfo = new SPDIFAudioSourceInfo();
spdifAudioSourceInfo.setAudioSource(SPDIFAudioSourceInfo.AUDIO_SOURCE_HDMI);//设置音源 -- HDMI
mRCSPController.setSPDIFSPDIFAudioSourceInfo(getConnectedDevice(), spdifAudioSourceInfo, null);

2.4 目录浏览

鉴于目录浏览功能较为复杂。独立出来说明;

函数名	参数	返回值	作用说明
addFileObserver	FileObserver: 2.4.1.2 FileObserver	void	注册目录浏览观察者
removeFileObserver	FileObserver: 2.4.1.2 FileObserver	void	注销目录浏览观察者
setPageSize	int: 每次浏览文件个数，范围：[1, 30]	void	设置每次浏览文件个数
getPageSize	void	int: 每次浏览文件个数	获取每次浏览文件个数
getOnlineStorage	FileStruct: 2.4.1.3 FileStruct	SDCardBean: 2.4.1.4 SDCardBean	获取在线存储器
getCurrentReadFile	SDCardBean: 2.4.1.4 SDCardBean	Folder: 2.4.1.5 Folder	获取当前浏览目录
getCurrentFileStructs	SDCardBean: 2.4.1.4 SDCardBean	List<FileStruct>: 子文件列表	读取当前目录下的已加载文件
isReading	void	boolean: 是否正在读取文件	是否正在读取文件
isOnline	int: 存储器索引号	boolean: 是否在线	存储器是否在线
gets	void	List<>: 存储器列表	获取存储器信息列表
getOnlineDev	void	List<>: 在线存储器列表	获取在线存储器列表
listFiles	Folder: 2.4.1.5 Folder int: 起始偏移	int: 2.4.1.1 操作结果码	目录浏览
listFiles	Folder: 2.4.1.5 Folder int: 起始偏移 boolean: 是否通知结果	int: 2.4.1.1 操作结果码	目录浏览
loadMore	SDCardBean: 2.4.1.4 SDCardBean	int: 2.4.1.1 操作结果码	加载更多文件信息
appenBrowse	FileStruct: 2.4.1.3 FileStruct SDCardBean: 2.4.1.4 SDCardBean	int: 2.4.1.1 操作结果码	浏览下一级目录
appenBrowse	Folder: 2.4.1.5 Folder	int: 2.4.1.1 操作结果码	浏览下一级目录
backBrowse	SDCardBean: 2.4.1.4 SDCardBean	int: 2.4.1.1 操作结果码	返回上一级目录(有回调)
backBrowse	SDCardBean: 2.4.1.4 SDCardBean boolean: 是否回调文件数据	int: 2.4.1.1 操作结果码	返回上一级目录
deleteFile	SDCardBean: 2.4.1.4 SDCardBean List<FileStruct>: 删除文件列表 DeleteCallback: 删除文件回调	int: 2.4.1.1 操作结果码	删除文件
deleteFile	SDCardBean: 2.4.1.4 SDCardBean List<FileStruct>: 删除文件列表 boolean: 是否需要准备环境 DeleteCallback: 删除文件回调	int: 2.4.1.1 操作结果码	删除文件
deleteFile	List<FileStruct>: 删除文件列表 boolean: 是否需要准备环境 DeleteCallback: 删除文件回调	int: 2.4.1.1 操作结果码	删除文件
playFile	FileStruct: 2.4.1.3 FileStruct SDCardBean: 2.4.1.4 SDCardBean	int: 2.4.1.1 操作结果码	播放音乐文件
playFile	RegFile: 2.4.1.6 RegFile	int: 2.4.1.1 操作结果码	播放音乐文件
formatDevice	SDCardBean: 2.4.1.4 SDCardBean OperatCallback: 操作回调	int: 2.4.1.1 操作结果码	格式化存储器
cleanCache	void	void	清除所有缓存
cleanCache	BluetoothDevice: 蓝牙设备	void	清除指定设备的所有缓存
cleanCache	SDCardBean: 2.4.1.4 SDCardBean	void	清除指定存储器的所有缓存

2.4.1 数据说明

2.4.1.1 操作结果码

名称	码值	描述
FileBrowseConstant#SUCCESS	0(0x0000)	成功结果
FileBrowseConstant#ERR_PARAM	4096(0x1001)	无效参数
FileBrowseConstant#ERR_BUSY	8200(0x2008)	系统繁忙
FileBrowseConstant#ERR_OPERATION_TIMEOUT	12304(0x3010)	操作超时
FileBrowseConstant#ERR_READING	12305(0x3011)	正在目录浏览
FileBrowseConstant#ERR_OFFLINE	12306(0x3012)	存储器下线
FileBrowseConstant#ERR_LOAD_FINISHED	24576(0x6000)	文件列表已加载完毕
FileBrowseConstant#ERR_BEYOND_MAX_DEPTH	24577(0x6001)	超过限制目录层级
FileBrowseConstant#ERR_NO_DATA	24578(0x6002)	丢失文件数据
FileBrowseConstant#ERR_FILE_NOT_IN_STORAGE	24579(0x6003)	文件结构与存储器不一致说明输入参数冲突

2.4.1.2 FileObserver

目录浏览观察者

public interface FileObserver {

     /**
      * 收到目录文件数据后回调
      *
      * @param fileStructs 文件结构列表
      */
     void onFileReceiver(List<FileStruct> fileStructs);

     /**
      * 一次文件读取结束
      *
      * @param isEnd 是否结束
      */
     void onFileReadStop(boolean isEnd);

     /**
      * 文件读取开始
      */
     void onFileReadStart();

     /**
      * 文件读取失败
      *
      * @param reason 错误码
      */
     void onFileReadFailed(int reason);

     /**
      * 设备的存储设备状态变化
      *
      * @param onLineCards 在线设备列表
      */
     void onSdCardStatusChange(List<> onLineCards);

     /**
      * 文件点播成功回调
      */
     void OnFlayCallback(boolean success);

 }

Note

文件结构, 2.4.1.3 FileStruct
存储器信息, 2.4.1.4 SDCardBean

2.4.1.3 FileStruct

文件结构

public class FileStruct implements IDataOp, Parcelable {

     /**
      * 是否文件
      *
      * <p>结果说明:
      * true -- 文件
      * false -- 文件夹</p>
      */
     private boolean file;
     /**
      * 是否Unicode编码
      *
      * <p>
      * 结果说明:
      * true -- Unicode编码
      * false -- ASCII编码
      * </p>
      */
     private boolean unicode;
     /**
      * 簇号。唯一标识
      */
     private int cluster = 0;
     /**
      * 文件夹序号
      */
     private short fileNum = 1;
     /**
      * 文件名
      */
     private String name = "";
     /**
      * 存储器类型
      */
     private byte devIndex;
}

2.4.1.4 SDCardBean

存储器信息

public class SDCardBean implements Parcelable {

 /**
  * SD卡类型
  */
 public static final int SD = 0;
 /**
  * USB类型
  */
 public static final int USB = 1;
 /**
  * Flash类型
  */
 public static final int FLASH = 2;
 /**
  * LineIn类型
  */
 public static final int LINEIN = 3;
 /**
  * Flash2类型
  */
 public static final int FLASH_2 = 4;

 //index
 /**
  * USB索引
  */
 public static final int INDEX_USB = 0;
 /**
  * SD0索引
  */
 public static final int INDEX_SD0 = 1;
 /**
  * SD1类型
  */
 public static final int INDEX_SD1 = 2;
 /**
  * Flash索引
  */
 public static final int INDEX_FLASH = 3;
 /**
  * 输入设备索引
  */
 public static final int INDEX_LINE_IN = 4;
 /**
  * Flash2索引
  */
 public static final int INDEX_FLASH2 = 5;


 /**
  * 存储器索引
  */
 private int index;
 /**
  * 存储器类型
  */
 private int type;
 /**
  * 存储器名称
  */
 private String name;
 /**
  * 存储器句柄
  */
 private int devHandler = -1;
 /**
  * 是否在线
  */
 private boolean online;
 /**
  * 操作设备
  */
 private BluetoothDevice device;
}

2.4.1.5 Folder

文件夹

public class Folder extends File {
  /**
   * 文件列表
   */
  private final transient List<File> files = new ArrayList<>();
  /**
   * 是否加载完成
   */
  private boolean isLoadFinish = false;
}

2.4.1.6 RegFile

资源文件

public class RegFile extends File {

}

public abstract class File extends FileStruct {

 /**
  * 父类文件夹
  */
 private transient final Folder parent;
 /**
  * 目录层级
  */
 private final int level;
}

2.4.2 目录浏览

FileObserver fileObserver = new FileObserver() {
    @Override
    public void onFileReceiver(List<FileStruct> fileStructs) {
        // 读取到文件列表，仅仅回调本次读取的文件列表
    }

    @Override
    public void onFileReadStop(boolean isEnd) {
        // 文件列表读取结束
    }

    @Override
    public void onFileReadStart() {
        // 开始文件列表读取
    }

    @Override
    public void onFileReadFailed(int reason) {
        // 文件列表读取失败
    }

    @Override
    public void onSdCardStatusChange(List<> onLineCards) {
        //在线设备有变化
    }

    @Override
    public void OnFlayCallback(boolean success) {
        //歌曲点播回调
    }
};
//第一步：注册观察者

// 第2步：获取在线设备列表，可以通过fileObserver处理设备状态变化
FileBrowseManager.getInstance().addFileObserver(fileObserver);

// 第3步：读取当前设备正在读的当前目录
List<> list = FileBrowseManager.getInstance().getOnlineDev();
if(list.size()<1){
    //没有在线设备
    return;
}
  = list.get(0);//获取设备，如果有多个设备，请根据需求获取相应的设备
Folder currentFolder = FileBrowseManager.getInstance().getCurrentReadFile();

//第4步：获取当前目录下已经读了但在缓存中的子文件
List<FileStruct> fileStructs = currentFolder.getChildFileStructs();

//第5步：浏览操作
//加载更多
FileBrowseManager.getInstance().loadMore();
//进入下一级目录
FileStruct fileStruct = currentFolder.getChildFileStructs().get(0);//根据需要获取需要读取的文件夹
FileBrowseManager.getInstance().appenBrowse(fileStruct, );
//返回上一级目录没有列表回调
boolean hasEvent = true;//是否需要FileObserver的事件回调
FileBrowseManager.getInstance().backBrowse(,hasEvent);
//点播文件
FileBrowseManager.getInstance().playFile(fileStruct, );

2.4.3 文件删除

List<> list = FileBrowseManager.getInstance().getOnlineDev();
if(list.size() < 1){
    //没有在线设备
    return;
}
  = list.get(0);//获取设备，如果有多个设备，请根据需求获取相应的设备
List<FileStruct> fileStructs = new ArrayList<>();//注意fileStructs一定要是在中
boolean withEnv = false;//准备环境，一般使用false
FileBrowseManager.getInstance().deleteFile(, fileStructs,withEnv, new DeleteCallback() {
    @Override
    public void onSuccess(FileStruct fileStruct) {
        //成功
    }

    @Override
    public void onError(int code, FileStruct fileStruct) {
        //fileStruct 删除失败
    }

    @Override
    public void onFinish() {
        //删除结束，通过onError判断是否有删除失败的文件
    }
});

2.4.4 格式化

 //格式化，仅仅格式化设备
    List<> list = FileBrowseManager.getInstance().getOnlineDev();
if (list.size() < 1) {
    //没有在线设备
    return;
}
  = list.get(0);//获取设备，如果有多个设备，请根据需求获取相应的设备
FileBrowseManager.getInstance().formatDevice(, new OperatCallback() {
    @Override
    public void onSuccess() {
        //成功
    }

    @Override
    public void onError(int code) {
        //失败
    }
});

Warning

需要和固件工程师沟通，是否支持

2.4.5 注意事项

Important

格式化操作请和固件确认是否需要备份或者准备环境
删除文件操作请和固件确认是否需要备份或者准备环境

码值	说明
1	左耳按键
2	右耳按键

码值	说明
1	短按耳机
2	轻点两下耳机

码值	说明
1	未配对
2	未连接
3	已连接

码值	说明
0	全灭
1	红灯常亮
2	蓝灯常亮
3	红灯呼吸
4	蓝灯呼吸
5	红蓝交替快闪
6	红蓝交替慢闪