lxm
12 months ago
44 changed files with 3371 additions and 1624 deletions
Binary file not shown.
Binary file not shown.
@ -0,0 +1,700 @@ |
|||||
|
package com.yunqiinnovation.ble_service |
||||
|
|
||||
|
import android.Manifest |
||||
|
import android.annotation.SuppressLint |
||||
|
import android.bluetooth.BluetoothGatt |
||||
|
import android.bluetooth.BluetoothGattCharacteristic |
||||
|
import android.os.Handler |
||||
|
import android.os.Looper |
||||
|
import android.util.Log |
||||
|
import androidx.annotation.RequiresPermission |
||||
|
import java.util.* |
||||
|
|
||||
|
/** |
||||
|
* BLE指令发送器类：负责处理蓝牙设备的指令发送、接收和队列管理 |
||||
|
* 功能包括： |
||||
|
* 1. 指令队列管理 |
||||
|
* 2. 指令封装和CRC校验 |
||||
|
* 3. 指令发送和重试机制 |
||||
|
* 4. 响应超时处理 |
||||
|
* 5. 设备响应和通知处理 |
||||
|
*/ |
||||
|
class BleCommandSender { |
||||
|
|
||||
|
companion object { |
||||
|
private const val TAG = "BleCommandSender" |
||||
|
private const val REPLY_TIMEOUT_MS = 1000L // 响应超时时间1秒 |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 成员变量 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** 指令队列 */ |
||||
|
private val commandQueue: Queue<ByteArray> = LinkedList() |
||||
|
|
||||
|
/** 是否正在等待回复 */ |
||||
|
var isWaitingReply = true |
||||
|
private set |
||||
|
|
||||
|
/** 回复的指令类型 */ |
||||
|
var replyCommandType = 0xff |
||||
|
private set |
||||
|
|
||||
|
/** 响应超时处理器 */ |
||||
|
private val replyTimeoutHandler = Handler(Looper.getMainLooper()) |
||||
|
|
||||
|
/** 响应超时回调 */ |
||||
|
private val replyTimeoutRunnable = Runnable { |
||||
|
if (!isWaitingReply) { |
||||
|
Log.w(TAG, "命令响应超时，自动重置 isWaitingReply 为 true") |
||||
|
isWaitingReply = true |
||||
|
processNextCommand() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** 指令发送状态回调接口 */ |
||||
|
interface CommandSenderCallback { |
||||
|
/** |
||||
|
* 检查连接状态 |
||||
|
* @return 是否已连接 |
||||
|
*/ |
||||
|
fun isConnected(): Boolean |
||||
|
|
||||
|
/** |
||||
|
* 获取写入特征 |
||||
|
* @return 写入特征对象 |
||||
|
*/ |
||||
|
fun getWriteCharacteristic(): BluetoothGattCharacteristic? |
||||
|
|
||||
|
/** |
||||
|
* 获取GATT连接 |
||||
|
* @return GATT连接对象 |
||||
|
*/ |
||||
|
fun getBluetoothGatt(): BluetoothGatt? |
||||
|
|
||||
|
/** |
||||
|
* 通知设备信息接收 |
||||
|
* @param infoType 信息类型 |
||||
|
* @param infoData 信息数据 |
||||
|
*/ |
||||
|
fun notifyDeviceInfoReceived(infoType: Int, infoData: Map<String, Any>) |
||||
|
|
||||
|
/** |
||||
|
* 通知唤醒信号接收 |
||||
|
*/ |
||||
|
fun notifyWakeupSignalReceived() |
||||
|
|
||||
|
/** |
||||
|
* 获取录音文件对象 |
||||
|
* @return 录音文件对象 |
||||
|
*/ |
||||
|
fun getRecordFile(): RecordingFile? |
||||
|
|
||||
|
/** |
||||
|
* 获取重新压缩录音文件对象 |
||||
|
* @return 重新压缩录音文件对象 |
||||
|
*/ |
||||
|
fun getRecordFile1(): RecordingFile? |
||||
|
} |
||||
|
|
||||
|
private var callback: CommandSenderCallback? = null |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 公共方法 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* 设置回调接口 |
||||
|
* @param callback 回调接口实现 |
||||
|
*/ |
||||
|
fun setCallback(callback: CommandSenderCallback) { |
||||
|
this.callback = callback |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 发送命令到设备 - 通用方法 |
||||
|
* @param cmdType 命令类型 |
||||
|
* @param cmdData 命令数据 |
||||
|
* @return 是否成功发送 |
||||
|
*/ |
||||
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT) |
||||
|
fun sendCommand(cmdType: Byte, cmdData: ByteArray = byteArrayOf()): Boolean { |
||||
|
val callback = this.callback ?: run { |
||||
|
Log.e(TAG, "发送命令失败: 回调接口未设置") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
if (!callback.isConnected()) { |
||||
|
Log.e(TAG, "发送命令失败: 设备未连接") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
try { |
||||
|
// 创建命令包 |
||||
|
val cmdPacket = createCommandPacket(cmdType, cmdData) |
||||
|
|
||||
|
// 记录命令详情 |
||||
|
logCommandDetails(cmdType, cmdData, cmdPacket) |
||||
|
|
||||
|
// 获取写入特征 |
||||
|
val writeChar = callback.getWriteCharacteristic() ?: run { |
||||
|
Log.e(TAG, "发送命令失败: 写入特征未找到") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// 设置数据并发送 |
||||
|
writeChar.value = cmdPacket |
||||
|
|
||||
|
return if (isWaitingReply) { |
||||
|
// 直接发送 |
||||
|
val gatt = callback.getBluetoothGatt() |
||||
|
val isSuccess = gatt?.writeCharacteristic(writeChar) == true |
||||
|
if (isSuccess) { |
||||
|
isWaitingReply = false |
||||
|
startReplyTimeout() |
||||
|
true |
||||
|
} else { |
||||
|
Log.e(TAG, "发送命令失败: 写入特征失败") |
||||
|
false |
||||
|
} |
||||
|
} else { |
||||
|
// 加入队列等待发送 |
||||
|
commandQueue.offer(cmdPacket) |
||||
|
Log.d(TAG, "命令已加入队列，当前队列长度: ${commandQueue.size}") |
||||
|
true |
||||
|
} |
||||
|
|
||||
|
} catch (e: Exception) { |
||||
|
Log.e(TAG, "发送命令异常: ${e.message}", e) |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 处理命令响应，重置等待状态并处理下一个命令 |
||||
|
* @param responseCommandType 响应的命令类型 |
||||
|
*/ |
||||
|
fun onCommandResponse(responseCommandType: Int) { |
||||
|
isWaitingReply = true |
||||
|
replyCommandType = responseCommandType |
||||
|
replyTimeoutHandler.removeCallbacks(replyTimeoutRunnable) |
||||
|
processNextCommand() |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 处理设备响应数据 - 从BleService移动过来 |
||||
|
* @param data 响应数据 |
||||
|
*/ |
||||
|
@SuppressLint("StaticFieldLeak") |
||||
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT) |
||||
|
fun processDeviceResponse(data: ByteArray) { |
||||
|
Log.d( |
||||
|
TAG, |
||||
|
"收到设备响应: ${data.joinToString(", ") { "0x${(it.toInt() and 0xFF).toString(16)}" }}" |
||||
|
) |
||||
|
if (data.size < 3) { |
||||
|
Log.e(TAG, "设备响应数据格式错误：数据长度过短") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
val header = data[0] // 0xBB |
||||
|
val cmdType = data[1].toInt() and 0xFF |
||||
|
|
||||
|
// 判断命令失败响应（长度为0） |
||||
|
if (data.size == 4 && data[2].toInt() and 0xFF == 0) { |
||||
|
Log.w(TAG, "命令 0x${cmdType.toString(16)} 执行失败") |
||||
|
// 创建失败结果Map |
||||
|
val resultMap = mapOf( |
||||
|
"success" to false, |
||||
|
"command" to cmdType, |
||||
|
"rawData" to byteArrayOf() |
||||
|
) |
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
// 通知指令发送器处理响应 |
||||
|
onCommandResponse(cmdType) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// 正常响应处理 |
||||
|
val length = data[2].toInt() and 0xFF |
||||
|
|
||||
|
// 检查数据长度 |
||||
|
if (data.size != length + 4) { // 帧头 + 命令 + 长度 + 数据 + CRC |
||||
|
Log.e(TAG, "设备响应数据长度不匹配: 期望=${length + 4}, 实际=${data.size}") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// 计算CRC校验 - 修正：计算除最后一个CRC字节外的所有字节 |
||||
|
val payload = data.sliceArray(0 until data.size - 1) |
||||
|
val calculatedCrc = calculateCrc8Maxim(payload, payload.size) |
||||
|
val receivedCrc = data[data.size - 1].toInt() and 0xFF |
||||
|
|
||||
|
if (calculatedCrc.toInt() and 0xFF != receivedCrc) { |
||||
|
Log.e( |
||||
|
TAG, |
||||
|
"设备响应CRC校验失败: 计算=${calculatedCrc.toInt() and 0xFF}, 接收=${receivedCrc}" |
||||
|
) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// 提取响应数据 |
||||
|
val responseData = if (length > 0) ByteArray(length) else ByteArray(0) |
||||
|
if (length > 0) { |
||||
|
System.arraycopy(data, 3, responseData, 0, length) |
||||
|
} |
||||
|
|
||||
|
Log.d( |
||||
|
TAG, |
||||
|
"收到设备响应: CMD=0x${cmdType.toString(16)}, 数据=${ |
||||
|
responseData.joinToString(", ") { |
||||
|
"0x${ |
||||
|
(it.toInt() and 0xFF).toString(16) |
||||
|
}" |
||||
|
} |
||||
|
}" |
||||
|
) |
||||
|
// 通知指令发送器处理响应 |
||||
|
onCommandResponse(cmdType) |
||||
|
// 根据命令类型处理不同的响应 |
||||
|
when (cmdType) { |
||||
|
BleConst.CMD_GET_VERSION -> { |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to "versionInfo", |
||||
|
"rawData" to responseData |
||||
|
) |
||||
|
|
||||
|
if (responseData.isNotEmpty()) { |
||||
|
// 转换为字符串前，确认是否是有效的ASCII字符 |
||||
|
val version = |
||||
|
responseData |
||||
|
.map { it.toInt() and 0xFF } // 转为无符号整数 (0-255) |
||||
|
.dropWhile { it == 0xFF } // 仅丢弃开头的连续 255 |
||||
|
.joinToString(".") { it.toString() } |
||||
|
resultMap["version"] = version |
||||
|
Log.i(TAG, "接收到目标版本号: $version") |
||||
|
} |
||||
|
|
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
} |
||||
|
|
||||
|
BleConst.CMD_GET_PRODUCT_ID -> { |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to "productId", |
||||
|
"rawData" to responseData |
||||
|
) |
||||
|
|
||||
|
if (responseData.isNotEmpty()) { |
||||
|
// 转换为字符串前，确认是否是有效的ASCII字符 |
||||
|
val productId = |
||||
|
responseData.joinToString(".") { (it.toInt() and 0xFF).toString() } |
||||
|
resultMap["productId"] = productId |
||||
|
Log.i(TAG, "接收到产品ID: $productId") |
||||
|
} |
||||
|
|
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
} |
||||
|
|
||||
|
BleConst.CMD_GET_COLOR_ID -> { |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to "colorInfo", |
||||
|
"rawData" to responseData |
||||
|
) |
||||
|
|
||||
|
if (responseData.isNotEmpty()) { |
||||
|
val colorId = (responseData[0].toInt() and 0xFF).toString() |
||||
|
resultMap["colorId"] = colorId |
||||
|
Log.i(TAG, "接收到耳机颜色ID: $colorId") |
||||
|
} |
||||
|
|
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
} |
||||
|
|
||||
|
BleConst.CMD_GET_BATTERY_INFO -> { |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to "batteryInfo", |
||||
|
"rawData" to responseData |
||||
|
) |
||||
|
|
||||
|
if (responseData.isNotEmpty() && responseData.size >= 3) { |
||||
|
// 处理电池信息 - 左耳、右耳、充电仓 |
||||
|
val leftEarBattery = responseData[0].toInt() and 0x7F |
||||
|
val leftEarCharging = (responseData[0].toInt() and 0x80) != 0 |
||||
|
|
||||
|
val rightEarBattery = |
||||
|
if (responseData.size > 1) responseData[1].toInt() and 0x7F else 0 |
||||
|
val rightEarCharging = |
||||
|
if (responseData.size > 1) (responseData[1].toInt() and 0x80) != 0 else false |
||||
|
|
||||
|
val caseBattery = |
||||
|
if (responseData.size > 2) responseData[2].toInt() and 0x7F else 0 |
||||
|
val caseCharging = |
||||
|
if (responseData.size > 2) (responseData[2].toInt() and 0x80) != 0 else false |
||||
|
|
||||
|
// 添加到结果Map |
||||
|
resultMap["leftEarBattery"] = leftEarBattery |
||||
|
resultMap["leftEarCharging"] = leftEarCharging |
||||
|
resultMap["rightEarBattery"] = rightEarBattery |
||||
|
resultMap["rightEarCharging"] = rightEarCharging |
||||
|
resultMap["caseBattery"] = caseBattery |
||||
|
resultMap["caseCharging"] = caseCharging |
||||
|
resultMap["batteryLevel"] = leftEarBattery // 整体电量用左耳表示 |
||||
|
|
||||
|
Log.i( |
||||
|
TAG, "接收到电量信息: 左耳=${leftEarBattery}% " + |
||||
|
"(${if (leftEarCharging) "充电中" else "未充电"}), 右耳=${rightEarBattery}% " + |
||||
|
"(${if (rightEarCharging) "充电中" else "未充电"}), 充电仓=${caseBattery}% " + |
||||
|
"(${if (caseCharging) "充电中" else "未充电"})" |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
} |
||||
|
|
||||
|
BleConst.CMD_CONTROL_CODEC -> { |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to cmdType, |
||||
|
"rawData" to responseData |
||||
|
) |
||||
|
|
||||
|
if (responseData.isNotEmpty() && responseData.size >= 2) { |
||||
|
val codecStatus = responseData[0].toInt() and 0xFF |
||||
|
val channelMode = responseData[1].toInt() and 0xFF |
||||
|
|
||||
|
// 解码状态描述 |
||||
|
val statusDesc = when (codecStatus) { |
||||
|
BleConst.CODEC_CONTROL_CLOSE -> "已关闭编解码" |
||||
|
BleConst.CODEC_CONTROL_DECODE_ON -> "已打开解码" |
||||
|
BleConst.CODEC_CONTROL_A2DP_PLAY -> "A2DP播放模式" |
||||
|
BleConst.CODEC_CONTROL_CALL_RECORD_PLAY -> "通话记录播放模式" |
||||
|
BleConst.CODEC_CONTROL_ENCODE_ON -> "已打开编码" |
||||
|
else -> "未知状态($codecStatus)" |
||||
|
} |
||||
|
|
||||
|
// 处理录音文件 |
||||
|
if (codecStatus == BleConst.CODEC_CONTROL_DECODE_ON || |
||||
|
codecStatus == BleConst.CODEC_CONTROL_A2DP_PLAY || |
||||
|
codecStatus == BleConst.CODEC_CONTROL_CALL_RECORD_PLAY || |
||||
|
codecStatus == BleConst.CODEC_CONTROL_ENCODE_ON |
||||
|
) { |
||||
|
callback?.getRecordFile1()?.closeFile() |
||||
|
callback?.getRecordFile1()?.creatingFiles() |
||||
|
callback?.getRecordFile()?.closeFile() |
||||
|
callback?.getRecordFile()?.creatingFiles() |
||||
|
} else if (codecStatus == BleConst.CODEC_CONTROL_CLOSE) { |
||||
|
callback?.getRecordFile()?.closeFile() |
||||
|
callback?.getRecordFile1()?.closeFile() |
||||
|
} |
||||
|
|
||||
|
Log.d(TAG, "收到设备响应,channelMode: $channelMode") |
||||
|
|
||||
|
// 声道模式描述 |
||||
|
val channelDesc = when (channelMode) { |
||||
|
BleConst.AUDIO_CHANNEL_LEFT -> "左声道" |
||||
|
BleConst.AUDIO_CHANNEL_RIGHT -> "右声道" |
||||
|
BleConst.AUDIO_CHANNEL_STEREO -> "立体声" |
||||
|
else -> "未知声道($channelMode)" |
||||
|
} |
||||
|
|
||||
|
resultMap["codecStatus"] = codecStatus |
||||
|
resultMap["channelMode"] = channelMode |
||||
|
resultMap["statusDesc"] = statusDesc |
||||
|
resultMap["channelDesc"] = channelDesc |
||||
|
|
||||
|
Log.i(TAG, "编解码控制响应: $statusDesc, $channelDesc") |
||||
|
} else if (responseData.isNotEmpty() && responseData.size == 1) { |
||||
|
val codecStatus = responseData[0].toInt() and 0xFF |
||||
|
if (codecStatus == 0x00) { |
||||
|
Log.d(TAG, "收到设备响应:失败,codecStatus: $codecStatus") |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to "Error", |
||||
|
"rawData" to responseData |
||||
|
) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
} |
||||
|
|
||||
|
else -> { |
||||
|
// 对于未知命令，返回原始数据 |
||||
|
val resultMap = mapOf( |
||||
|
"success" to true, |
||||
|
"command" to cmdType, |
||||
|
"rawData" to responseData, |
||||
|
"isUnknown" to true |
||||
|
) |
||||
|
Log.d(TAG, "收到未知命令响应: 0x${cmdType.toString(16)}") |
||||
|
callback?.notifyDeviceInfoReceived(cmdType, resultMap) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 处理设备主动上报数据 - 帧头为0xCC |
||||
|
* 将可见性修改为internal，允许同包内的BleService类访问 |
||||
|
*/ |
||||
|
fun processDeviceNotification(data: ByteArray) { |
||||
|
Log.d( |
||||
|
TAG, |
||||
|
"收到设备主动上报: ${data.joinToString(", ") { "0x${(it.toInt() and 0xFF).toString(16)}" }}" |
||||
|
) |
||||
|
if (data.size < 3) { |
||||
|
Log.e(TAG, "设备主动上报数据格式错误：数据长度过短") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
val header = data[0] // 0xCC |
||||
|
val infoType = data[1].toInt() and 0xFF |
||||
|
val length = data[2].toInt() and 0xFF |
||||
|
|
||||
|
// 检查数据长度 |
||||
|
if (data.size != length + 4) { // 帧头 + 类型 + 长度 + 数据 + CRC |
||||
|
Log.e(TAG, "设备主动上报数据长度不匹配: 期望=${length + 4}, 实际=${data.size}") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// 计算CRC校验 - 修正：计算除最后一个CRC字节外的所有字节 |
||||
|
val payload = data.sliceArray(0 until data.size - 1) |
||||
|
val calculatedCrc = calculateCrc8Maxim(payload, payload.size) |
||||
|
val receivedCrc = data[data.size - 1].toInt() and 0xFF |
||||
|
|
||||
|
if (calculatedCrc.toInt() and 0xFF != receivedCrc) { |
||||
|
Log.e( |
||||
|
TAG, |
||||
|
"设备主动上报CRC校验失败: 计算=${calculatedCrc.toInt() and 0xFF}, 接收=${receivedCrc}" |
||||
|
) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// 提取上报数据 |
||||
|
val notifyData = if (length > 0) ByteArray(length) else ByteArray(0) |
||||
|
if (length > 0) { |
||||
|
System.arraycopy(data, 3, notifyData, 0, length) |
||||
|
} |
||||
|
|
||||
|
Log.d( |
||||
|
TAG, |
||||
|
"收到设备主动上报: 类型=0x${infoType.toString(16)}, 数据=${ |
||||
|
notifyData.joinToString(", ") { |
||||
|
"0x${ |
||||
|
(it.toInt() and 0xFF).toString(16) |
||||
|
}" |
||||
|
} |
||||
|
}" |
||||
|
) |
||||
|
|
||||
|
// 根据上报类型处理 |
||||
|
when (infoType) { |
||||
|
BleConst.CMD_GET_BATTERY_INFO -> { // 电量信息 |
||||
|
val resultMap = mutableMapOf<String, Any>( |
||||
|
"success" to true, |
||||
|
"command" to infoType, |
||||
|
"rawData" to notifyData, |
||||
|
"isNotification" to true // 标记为主动上报 |
||||
|
) |
||||
|
|
||||
|
if (notifyData.isNotEmpty() && notifyData.size >= 3) { |
||||
|
// 处理电池信息 - 左耳、右耳、充电仓 |
||||
|
val leftEarBattery = notifyData[0].toInt() and 0x7F |
||||
|
val leftEarCharging = (notifyData[0].toInt() and 0x80) != 0 |
||||
|
|
||||
|
val rightEarBattery = |
||||
|
if (notifyData.size > 1) notifyData[1].toInt() and 0x7F else 0 |
||||
|
val rightEarCharging = |
||||
|
if (notifyData.size > 1) (notifyData[1].toInt() and 0x80) != 0 else false |
||||
|
|
||||
|
val caseBattery = if (notifyData.size > 2) notifyData[2].toInt() and 0x7F else 0 |
||||
|
val caseCharging = |
||||
|
if (notifyData.size > 2) (notifyData[2].toInt() and 0x80) != 0 else false |
||||
|
|
||||
|
|
||||
|
// 添加到结果Map |
||||
|
resultMap["leftEarBattery"] = leftEarBattery |
||||
|
resultMap["leftEarCharging"] = leftEarCharging |
||||
|
resultMap["rightEarBattery"] = rightEarBattery |
||||
|
resultMap["rightEarCharging"] = rightEarCharging |
||||
|
resultMap["caseBattery"] = caseBattery |
||||
|
resultMap["caseCharging"] = caseCharging |
||||
|
resultMap["batteryLevel"] = leftEarBattery // 整体电量用左耳表示 |
||||
|
|
||||
|
Log.i( |
||||
|
TAG, "收到主动上报电量信息: 左耳=${leftEarBattery}% " + |
||||
|
"(${if (leftEarCharging) "充电中" else "未充电"}), 右耳=${rightEarBattery}% " + |
||||
|
"(${if (rightEarCharging) "充电中" else "未充电"}), 充电仓=${caseBattery}% " + |
||||
|
"(${if (caseCharging) "充电中" else "未充电"})" |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
callback?.notifyDeviceInfoReceived(infoType, resultMap) |
||||
|
} |
||||
|
|
||||
|
BleConst.CMD_WAKE_UP -> { |
||||
|
Log.i(TAG, "收到唤醒指令") |
||||
|
// 接收到唤醒信号，打开编码器 (设备侧) |
||||
|
|
||||
|
callback?.notifyWakeupSignalReceived() |
||||
|
|
||||
|
} |
||||
|
// 可以在这里添加其他主动上报类型的处理 |
||||
|
else -> { |
||||
|
// 对于未知上报类型，返回原始数据 |
||||
|
val resultMap = mapOf( |
||||
|
"success" to true, |
||||
|
"command" to infoType, |
||||
|
"rawData" to notifyData, |
||||
|
"isUnknown" to true, |
||||
|
"isNotification" to true // 标记为主动上报 |
||||
|
) |
||||
|
Log.d(TAG, "收到未知主动上报类型: 0x${infoType.toString(16)}") |
||||
|
callback?.notifyDeviceInfoReceived(infoType, resultMap) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* 清空命令队列 |
||||
|
*/ |
||||
|
fun clearCommandQueue() { |
||||
|
commandQueue.clear() |
||||
|
Log.d(TAG, "命令队列已清空") |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 获取当前队列长度 |
||||
|
* @return 队列中待发送的命令数量 |
||||
|
*/ |
||||
|
fun getQueueSize(): Int = commandQueue.size |
||||
|
|
||||
|
/** |
||||
|
* 重置发送状态 |
||||
|
*/ |
||||
|
fun reset() { |
||||
|
isWaitingReply = true |
||||
|
replyCommandType = 0xff |
||||
|
replyTimeoutHandler.removeCallbacks(replyTimeoutRunnable) |
||||
|
clearCommandQueue() |
||||
|
Log.d(TAG, "指令发送器已重置") |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 私有方法 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* 创建命令包 |
||||
|
* @param cmdType 命令类型 |
||||
|
* @param cmdData 命令数据 |
||||
|
* @return 完整的命令包（包含帧头、命令、长度、数据、CRC） |
||||
|
*/ |
||||
|
private fun createCommandPacket(cmdType: Byte, cmdData: ByteArray): ByteArray { |
||||
|
val cmdLength = cmdData.size |
||||
|
val cmdPacket = ByteArray(4 + cmdLength) // 帧头 + 命令 + 长度 + 数据 + CRC |
||||
|
|
||||
|
// 帧头 |
||||
|
cmdPacket[0] = BleConst.APP_REQUEST_HEADER |
||||
|
// 命令类型 |
||||
|
cmdPacket[1] = cmdType |
||||
|
// 命令长度 |
||||
|
cmdPacket[2] = cmdLength.toByte() |
||||
|
|
||||
|
// 填充命令数据（如果有） |
||||
|
if (cmdLength > 0) { |
||||
|
System.arraycopy(cmdData, 0, cmdPacket, 3, cmdLength) |
||||
|
} |
||||
|
|
||||
|
// 计算CRC - 对帧头到数据的所有字节进行校验 (不包括CRC自身) |
||||
|
val crcPayload = cmdPacket.sliceArray(0 until cmdPacket.size - 1) |
||||
|
val crc = calculateCrc8Maxim(crcPayload, crcPayload.size) |
||||
|
|
||||
|
// 设置CRC |
||||
|
cmdPacket[3 + cmdLength] = crc |
||||
|
|
||||
|
return cmdPacket |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 记录命令详情 |
||||
|
* @param cmdType 命令类型 |
||||
|
* @param cmdData 命令数据 |
||||
|
* @param cmdPacket 完整命令包 |
||||
|
*/ |
||||
|
private fun logCommandDetails(cmdType: Byte, cmdData: ByteArray, cmdPacket: ByteArray) { |
||||
|
val crc = cmdPacket[cmdPacket.size - 1] |
||||
|
Log.d( |
||||
|
TAG, |
||||
|
"发送命令: CMD=0x${(cmdType.toInt() and 0xFF).toString(16)}, 长度=${cmdData.size}, " + |
||||
|
"数据=${cmdData.joinToString(", ") { "0x${(it.toInt() and 0xFF).toString(16)}" }}, " + |
||||
|
"CRC=0x${(crc.toInt() and 0xFF).toString(16)}" |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 处理队列中的下一个命令 |
||||
|
*/ |
||||
|
private fun processNextCommand() { |
||||
|
if (commandQueue.isEmpty()) { |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
val callback = this.callback ?: return |
||||
|
val nextCmd = commandQueue.poll() ?: return |
||||
|
|
||||
|
val writeChar = callback.getWriteCharacteristic() ?: run { |
||||
|
Log.e(TAG, "处理下一个命令失败: 写入特征未找到") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
val gatt = callback.getBluetoothGatt() ?: run { |
||||
|
Log.e(TAG, "处理下一个命令失败: GATT连接未找到") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
writeChar.value = nextCmd |
||||
|
val isSuccess = gatt.writeCharacteristic(writeChar) |
||||
|
if (isSuccess) { |
||||
|
isWaitingReply = false |
||||
|
startReplyTimeout() |
||||
|
Log.d(TAG, "发送队列中的下一个命令，剩余队列长度: ${commandQueue.size}") |
||||
|
} else { |
||||
|
Log.e(TAG, "发送队列中的命令失败") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 启动响应超时计时器 |
||||
|
*/ |
||||
|
private fun startReplyTimeout() { |
||||
|
replyTimeoutHandler.postDelayed(replyTimeoutRunnable, REPLY_TIMEOUT_MS) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 计算CRC8/MAXIM校验值 |
||||
|
* @param data 要校验的数据 |
||||
|
* @param length 数据长度 |
||||
|
* @return CRC8校验值 |
||||
|
*/ |
||||
|
private fun calculateCrc8Maxim(data: ByteArray, length: Int): Byte { |
||||
|
var crc = 0 |
||||
|
val polynomial = 0x31 |
||||
|
|
||||
|
for (i in 0 until length) { |
||||
|
crc = crc xor (data[i].toInt() and 0xFF) |
||||
|
for (j in 0 until 8) { |
||||
|
if (crc and 0x80 != 0) { |
||||
|
crc = ((crc shl 1) xor polynomial) and 0xFF |
||||
|
} else { |
||||
|
crc = (crc shl 1) and 0xFF |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return crc.toByte() |
||||
|
} |
||||
|
} |
||||
@ -1,72 +0,0 @@ |
|||||
package com.yunqiinnovation.ble_service |
|
||||
|
|
||||
import android.companion.AssociationInfo |
|
||||
import android.companion.CompanionDeviceService |
|
||||
import android.content.Intent |
|
||||
import android.os.Build |
|
||||
import android.os.IBinder |
|
||||
import androidx.annotation.RequiresApi |
|
||||
import android.util.Log |
|
||||
|
|
||||
/** |
|
||||
* BleCompanionService |
|
||||
* 用于监听配对设备的出现和消失 |
|
||||
* 注：此服务仅在Android 11 (API 30)及以上版本可用 |
|
||||
*/ |
|
||||
@RequiresApi(Build.VERSION_CODES.R) |
|
||||
class BleCompanionService : CompanionDeviceService() { |
|
||||
private val TAG = "BleCompanionService" |
|
||||
|
|
||||
override fun onCreate() { |
|
||||
super.onCreate() |
|
||||
Log.i(TAG, "BleCompanionService已创建") |
|
||||
} |
|
||||
|
|
||||
override fun onDeviceAppeared(info: AssociationInfo) { |
|
||||
super.onDeviceAppeared(info) |
|
||||
Log.i(TAG, "检测到配对设备出现: ${info.displayName}, ID: ${info.id}") |
|
||||
|
|
||||
// 当配对设备出现时，启动前台服务 |
|
||||
try { |
|
||||
val serviceIntent = Intent().apply { |
|
||||
// 尝试使用BleMediaService，如果不存在则回退到BleService |
|
||||
val serviceClassName = try { |
|
||||
Class.forName("com.yunqiinnovation.agent_service.BleMediaService").name |
|
||||
} catch (e: ClassNotFoundException) { |
|
||||
BleService::class.java.name |
|
||||
} |
|
||||
|
|
||||
setClassName(this@BleCompanionService, serviceClassName) |
|
||||
action = "android.intent.action.DEVICE_APPEARED" |
|
||||
putExtra("assocId", info.id) |
|
||||
putExtra("displayName", info.displayName) |
|
||||
|
|
||||
// 如果设备信息中有MAC地址，也可以传递 |
|
||||
// 使用反射获取MAC地址，因为deviceMacAddress在不同API版本可能不同或不存在 |
|
||||
try { |
|
||||
val macAddressMethod = info.javaClass.getMethod("getDeviceMacAddress") |
|
||||
val mac = macAddressMethod.invoke(info) as? String |
|
||||
mac?.let { putExtra("mac", it) } |
|
||||
} catch (e: Exception) { |
|
||||
Log.e(TAG, "获取设备MAC地址失败: ${e.message}", e) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 启动前台服务 |
|
||||
startForegroundService(serviceIntent) |
|
||||
Log.i(TAG, "已启动服务") |
|
||||
} catch (e: Exception) { |
|
||||
Log.e(TAG, "启动服务失败: ${e.message}", e) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
override fun onDeviceDisappeared(info: AssociationInfo) { |
|
||||
super.onDeviceDisappeared(info) |
|
||||
Log.i(TAG, "配对设备消失: ${info.displayName}, ID: ${info.id}") |
|
||||
|
|
||||
// 可以选择停止服务或执行其他清理操作 |
|
||||
} |
|
||||
|
|
||||
// 注意: 不需要重写 onBindCompanionDeviceService 和 onUnbindCompanionDeviceService |
|
||||
// 这些方法在 Android 12+ 才添加，我们可以使用父类的默认实现 |
|
||||
} |
|
||||
File diff suppressed because it is too large
@ -0,0 +1,506 @@ |
|||||
|
package com.yunqiinnovation.ble_service |
||||
|
|
||||
|
import android.os.Handler |
||||
|
import android.os.Looper |
||||
|
import android.util.Log |
||||
|
import com.jieli.jl_audio_decode.opus.model.OpusOption |
||||
|
import com.jieli.jl_audio_decode.callback.OnDecodeStreamCallback |
||||
|
import com.jieli.jl_audio_decode.callback.OnEncodeStreamCallback |
||||
|
import com.jieli.jl_audio_decode.opus.OpusManager |
||||
|
import com.jieli.jl_audio_decode.exceptions.OpusException |
||||
|
import java.util.concurrent.LinkedBlockingQueue |
||||
|
import java.util.concurrent.atomic.AtomicBoolean |
||||
|
|
||||
|
/** |
||||
|
* Opus音频编解码管理器 |
||||
|
* 负责处理音频数据的Opus编码和解码功能 |
||||
|
* |
||||
|
* 功能包括： |
||||
|
* 1. Opus解码流管理 |
||||
|
* 2. Opus编码流管理 |
||||
|
* 3. 音频数据缓冲和处理 |
||||
|
* 4. 编解码状态管理 |
||||
|
*/ |
||||
|
class OpusAudioManager { |
||||
|
|
||||
|
companion object { |
||||
|
private const val TAG = "OpusAudioManager" |
||||
|
|
||||
|
// 音频数据分块发送的常量 |
||||
|
private const val AUDIO_CHUNK_SIZE = 120 // 每次发送120字节 |
||||
|
private const val AUDIO_SEND_INTERVAL = 60L // 发送间隔60ms |
||||
|
|
||||
|
// 重发机制相关常量 |
||||
|
private const val MAX_RETRY_COUNT = 1 // 最大重试次数 |
||||
|
private const val RETRY_DELAY = 30L // 重试延迟时间(毫秒) |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 回调接口定义 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* Opus音频管理器回调接口 |
||||
|
*/ |
||||
|
interface OpusAudioCallback { |
||||
|
/** |
||||
|
* 音频数据解码完成回调 |
||||
|
* @param data 解码后的音频数据 |
||||
|
* @param channel 音频通道数 |
||||
|
*/ |
||||
|
fun onAudioDataDecoded(data: ByteArray, channel: Int) |
||||
|
|
||||
|
/** |
||||
|
* 音频数据编码完成回调 |
||||
|
* @param data 编码后的音频数据 |
||||
|
*/ |
||||
|
fun onAudioDataEncoded(data: ByteArray) |
||||
|
|
||||
|
/** |
||||
|
* 解码流状态变化回调 |
||||
|
* @param isStarted 是否已启动 |
||||
|
*/ |
||||
|
fun onDecodeStreamStateChanged(isStarted: Boolean) |
||||
|
|
||||
|
/** |
||||
|
* 编码流状态变化回调 |
||||
|
* @param isStarted 是否已启动 |
||||
|
*/ |
||||
|
fun onEncodeStreamStateChanged(isStarted: Boolean) |
||||
|
|
||||
|
/** |
||||
|
* 错误回调 |
||||
|
* @param errorType 错误类型 (decode/encode) |
||||
|
* @param code 错误代码 |
||||
|
* @param message 错误信息 |
||||
|
*/ |
||||
|
fun onError(errorType: String, code: Int, message: String?) |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 成员变量 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
// Opus解码器实例 |
||||
|
private var opusManager: OpusManager? = null |
||||
|
private var option: OpusOption? = null |
||||
|
|
||||
|
private var opusManager1: OpusManager? = null |
||||
|
private var option1: OpusOption? = null |
||||
|
private val mainHandler = Handler(Looper.getMainLooper()) |
||||
|
|
||||
|
// 解码音频数据队列和处理线程 |
||||
|
private val audioDataQueue = LinkedBlockingQueue<ByteArray>() |
||||
|
private var audioQueueProcessorThread: Thread? = null |
||||
|
|
||||
|
// 音频数据缓存 |
||||
|
private val audioDataBuffer = mutableListOf<Byte>() |
||||
|
|
||||
|
// 音频数据发送相关 |
||||
|
private val audioSendQueue = LinkedBlockingQueue<ByteArray>() |
||||
|
private var audioSendThread: Thread? = null |
||||
|
private val audioSendHandler = Handler(Looper.getMainLooper()) |
||||
|
private val isAudioSending = AtomicBoolean(false) |
||||
|
|
||||
|
// 音频数据缓冲区，用于累积数据到指定字节再发送 |
||||
|
private val audioBuffer = mutableListOf<Byte>() |
||||
|
|
||||
|
// 回调接口 |
||||
|
private var callback: OpusAudioCallback? = null |
||||
|
|
||||
|
// 初始化状态 |
||||
|
private var isInitialized = false |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 初始化和配置方法 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* 初始化Opus音频管理器 |
||||
|
* @return 是否初始化成功 |
||||
|
*/ |
||||
|
fun initialize(): Boolean { |
||||
|
if (isInitialized) return true |
||||
|
|
||||
|
try { |
||||
|
// 初始化OpusManager和OpusOption |
||||
|
opusManager = OpusManager() |
||||
|
option = OpusOption() |
||||
|
|
||||
|
opusManager1 = OpusManager() |
||||
|
option1 = OpusOption() |
||||
|
|
||||
|
// 启动队列处理 |
||||
|
startAudioQueueProcessing() |
||||
|
|
||||
|
isInitialized = true |
||||
|
Log.d(TAG, "OpusAudioManager初始化成功") |
||||
|
return true |
||||
|
} catch (e: OpusException) { |
||||
|
Log.e(TAG, "OpusAudioManager初始化失败: ${e.message}", e) |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 设置回调接口 |
||||
|
* @param callback 回调接口实例 |
||||
|
*/ |
||||
|
fun setCallback(callback: OpusAudioCallback?) { |
||||
|
this.callback = callback |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 清理资源 |
||||
|
*/ |
||||
|
fun cleanup() { |
||||
|
Log.d(TAG, "开始清理OpusAudioManager资源") |
||||
|
|
||||
|
// 停止编解码流 |
||||
|
stopDecodeStream() |
||||
|
stopEncodeStream() |
||||
|
|
||||
|
// 停止音频发送线程 |
||||
|
stopAudioSendThread() |
||||
|
|
||||
|
// 停止音频队列处理线程 |
||||
|
audioQueueProcessorThread?.interrupt() |
||||
|
audioQueueProcessorThread = null |
||||
|
|
||||
|
// 清理缓存 |
||||
|
synchronized(audioDataBuffer) { |
||||
|
audioDataBuffer.clear() |
||||
|
} |
||||
|
synchronized(audioBuffer) { |
||||
|
audioBuffer.clear() |
||||
|
} |
||||
|
audioDataQueue.clear() |
||||
|
audioSendQueue.clear() |
||||
|
|
||||
|
// 清理Opus相关资源 |
||||
|
opusManager = null |
||||
|
option = null |
||||
|
opusManager1 = null |
||||
|
option1 = null |
||||
|
callback = null |
||||
|
|
||||
|
isInitialized = false |
||||
|
Log.d(TAG, "OpusAudioManager资源清理完成") |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// Opus解码相关方法 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* 开始Opus数据流解码 |
||||
|
* @param hasHeader 是否包含文件头，通常BLE传输的Opus没有文件头 |
||||
|
* @param channel 音频通道数 |
||||
|
* @param sampleRate 采样率，确认设备端Opus编码采样率 |
||||
|
* @param packetSize 包大小，确认设备端Opus编码帧长 |
||||
|
* @return 是否成功开始解码 |
||||
|
*/ |
||||
|
fun startDecodeStream( |
||||
|
hasHeader: Boolean = false, |
||||
|
channel: Int = 1, |
||||
|
sampleRate: Int = 16000, |
||||
|
packetSize: Int = 40 |
||||
|
): Boolean { |
||||
|
if (!isInitialized || opusManager == null) { |
||||
|
Log.e(TAG, "OpusManager未初始化，无法开始解码") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// 如果已经在解码流，先停止 |
||||
|
if (opusManager?.isDecodeStream == true) { |
||||
|
opusManager?.stopDecodeStream() |
||||
|
Log.d(TAG, "已停止正在进行的Opus解码流") |
||||
|
} |
||||
|
|
||||
|
// 清理音频数据缓存，确保开始时是干净的状态 |
||||
|
synchronized(audioDataBuffer) { |
||||
|
audioDataBuffer.clear() |
||||
|
Log.d(TAG, "开始解码前已清理音频数据缓存") |
||||
|
} |
||||
|
|
||||
|
// 配置解码参数 |
||||
|
option?.apply { |
||||
|
setHasHead(hasHeader) |
||||
|
setChannel(channel) |
||||
|
setSampleRate(sampleRate) |
||||
|
setPacketSize(packetSize) |
||||
|
} |
||||
|
|
||||
|
Log.d(TAG, "准备开始Opus数据流解码, 参数: hasHeader=$hasHeader, channel=$channel, sampleRate=$sampleRate, packetSize=$packetSize") |
||||
|
|
||||
|
try { |
||||
|
opusManager?.startDecodeStream(option, object : OnDecodeStreamCallback { |
||||
|
override fun onDecodeStream(data: ByteArray?) { |
||||
|
if (data != null) { |
||||
|
val channelCount = option?.getChannel() ?: 1 |
||||
|
if (channelCount >= 1) { |
||||
|
callback?.onAudioDataDecoded(data, channelCount) |
||||
|
} else { |
||||
|
// Log.e(TAG, "Opus解码数据错误: ${data.size} bytes") |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
override fun onStart() { |
||||
|
Log.i(TAG, "Opus数据流解码已开始") |
||||
|
callback?.onDecodeStreamStateChanged(true) |
||||
|
} |
||||
|
|
||||
|
override fun onComplete(outPath: String?) { |
||||
|
Log.i(TAG, "Opus数据流解码完成: $outPath") |
||||
|
callback?.onDecodeStreamStateChanged(false) |
||||
|
} |
||||
|
|
||||
|
override fun onError(code: Int, message: String?) { |
||||
|
Log.e(TAG, "Opus数据流解码错误: [$code] $message") |
||||
|
callback?.onError("decode", code, message) |
||||
|
callback?.onDecodeStreamStateChanged(false) |
||||
|
} |
||||
|
}) |
||||
|
|
||||
|
return true |
||||
|
} catch (e: Exception) { |
||||
|
Log.e(TAG, "启动Opus解码流失败: ${e.message}", e) |
||||
|
callback?.onError("decode", -1, e.message) |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 停止Opus数据流解码 |
||||
|
* @return 是否成功停止解码 |
||||
|
*/ |
||||
|
fun stopDecodeStream(): Boolean { |
||||
|
if (opusManager?.isDecodeStream == true) { |
||||
|
opusManager?.stopDecodeStream() |
||||
|
|
||||
|
// 清理音频数据缓存 |
||||
|
synchronized(audioDataBuffer) { |
||||
|
audioDataBuffer.clear() |
||||
|
Log.d(TAG, "已清理音频数据缓存") |
||||
|
} |
||||
|
|
||||
|
Log.i(TAG, "已停止Opus数据流解码") |
||||
|
callback?.onDecodeStreamStateChanged(false) |
||||
|
return true |
||||
|
} |
||||
|
Log.d(TAG, "Opus数据流未在解码或OpusManager未初始化") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 处理接收到的音频数据进行解码 |
||||
|
* @param data 音频数据 (Opus编码) |
||||
|
*/ |
||||
|
fun processAudioData(data: ByteArray) { |
||||
|
if (!isInitialized) { |
||||
|
Log.w(TAG, "OpusAudioManager未初始化，忽略音频数据") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
if (opusManager?.isDecodeStream == true) { |
||||
|
// 将数据加入队列进行异步处理 |
||||
|
audioDataQueue.offer(data) |
||||
|
} else { |
||||
|
Log.d(TAG, "Opus解码流未启动，忽略音频数据") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// Opus编码相关方法 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* 开始Opus数据流编码 |
||||
|
* @return 是否成功开始编码 |
||||
|
*/ |
||||
|
fun startEncodeStream(): Boolean { |
||||
|
if (!isInitialized || opusManager1 == null) { |
||||
|
Log.e(TAG, "OpusManager未初始化，无法开始编码") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// 如果已经在编码流，先停止 |
||||
|
if (opusManager1?.isEncodeStream == true) { |
||||
|
Log.d(TAG, "Opus编码流已在运行") |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
// 配置解码参数 |
||||
|
option1?.apply { |
||||
|
setHasHead(false) |
||||
|
setChannel(1) |
||||
|
setSampleRate(16000) |
||||
|
setPacketSize(40) |
||||
|
} |
||||
|
try { |
||||
|
Log.d(TAG, "准备开始Opus数据流编码") |
||||
|
opusManager1?.startEncodeStream(object : OnEncodeStreamCallback { |
||||
|
override fun onEncodeStream(data: ByteArray?) { |
||||
|
Log.d(TAG, "Opus编码回调收到数据，大小: ${data?.size ?: 0} bytes") |
||||
|
if (data != null) { |
||||
|
|
||||
|
// 编码完成的数据处理： |
||||
|
// 1. 通知回调 |
||||
|
callback?.onAudioDataEncoded(data) |
||||
|
|
||||
|
// // 2. 将编码后的数据加入发送队列进行分块发送 |
||||
|
// addAudioDataToSendQueue(data) |
||||
|
} else { |
||||
|
Log.w(TAG, "编码回调收到空数据") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
override fun onStart() { |
||||
|
Log.i(TAG, "Opus数据流编码已开始") |
||||
|
callback?.onEncodeStreamStateChanged(true) |
||||
|
} |
||||
|
|
||||
|
override fun onComplete(outPath: String?) { |
||||
|
Log.i(TAG, "Opus数据流编码完成: $outPath") |
||||
|
callback?.onEncodeStreamStateChanged(false) |
||||
|
} |
||||
|
|
||||
|
override fun onError(code: Int, message: String?) { |
||||
|
Log.e(TAG, "Opus数据流编码错误: [$code] $message") |
||||
|
callback?.onError("encode", code, message) |
||||
|
callback?.onEncodeStreamStateChanged(false) |
||||
|
} |
||||
|
}) |
||||
|
|
||||
|
return true |
||||
|
} catch (e: Exception) { |
||||
|
Log.e(TAG, "启动Opus编码流失败: ${e.message}", e) |
||||
|
callback?.onError("encode", -1, e.message) |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 停止Opus数据流编码 |
||||
|
* @return 是否成功停止编码 |
||||
|
*/ |
||||
|
fun stopEncodeStream(): Boolean { |
||||
|
if (opusManager1?.isEncodeStream == true) { |
||||
|
opusManager1?.stopEncodeStream() |
||||
|
stopAudioSendThread() // 停止音频发送线程 |
||||
|
Log.i(TAG, "已停止Opus数据流编码") |
||||
|
callback?.onEncodeStreamStateChanged(false) |
||||
|
return true |
||||
|
} |
||||
|
Log.d(TAG, "Opus数据流未在编码或OpusManager未初始化") |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 写入外部音频数据到Opus编码流 |
||||
|
* 该函数用于将外部音频数据（如麦克风录音）写入到Opus编码器中 |
||||
|
* |
||||
|
* @param data 音频数据字节数组，通常为PCM格式 |
||||
|
*/ |
||||
|
fun writeExternalAudioData(data: ByteArray) { |
||||
|
if (!isInitialized || opusManager1 == null) { |
||||
|
Log.e(TAG, "OpusManager未初始化") |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// 如果已经在编码流中，直接写入数据 |
||||
|
if (opusManager1?.isEncodeStream == true) { |
||||
|
Log.d(TAG, "正在进行Opus编码流，写入音频数据") |
||||
|
// 将外部音频数据写入编码流 |
||||
|
opusManager1?.writeEncodeStream(data) |
||||
|
} else { |
||||
|
Log.w(TAG, "Opus编码流未启动，无法写入音频数据") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 状态查询方法 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
/** |
||||
|
* 检查是否正在解码 |
||||
|
* @return 是否正在解码 |
||||
|
*/ |
||||
|
fun isDecoding(): Boolean { |
||||
|
return opusManager?.isDecodeStream == true |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 检查是否正在编码 |
||||
|
* @return 是否正在编码 |
||||
|
*/ |
||||
|
fun isEncoding(): Boolean { |
||||
|
return opusManager1?.isEncodeStream == true |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 检查是否已初始化 |
||||
|
* @return 是否已初始化 |
||||
|
*/ |
||||
|
fun isInitialized(): Boolean { |
||||
|
return isInitialized |
||||
|
} |
||||
|
|
||||
|
// ====================================================================================================== |
||||
|
// 私有方法 - 音频数据处理 |
||||
|
// ====================================================================================================== |
||||
|
|
||||
|
|
||||
|
/** |
||||
|
* 停止音频发送线程 |
||||
|
*/ |
||||
|
private fun stopAudioSendThread() { |
||||
|
isAudioSending.set(false) |
||||
|
audioSendThread?.interrupt() |
||||
|
|
||||
|
try { |
||||
|
audioSendThread?.join(1000) // 等待最多1秒 |
||||
|
} catch (e: InterruptedException) { |
||||
|
Log.w(TAG, "等待音频发送线程停止时被中断") |
||||
|
} |
||||
|
|
||||
|
audioSendThread = null |
||||
|
audioSendQueue.clear() |
||||
|
|
||||
|
synchronized(audioBuffer) { |
||||
|
audioBuffer.clear() |
||||
|
} |
||||
|
|
||||
|
Log.d(TAG, "音频发送线程已停止") |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 启动音频队列处理线程 |
||||
|
*/ |
||||
|
private fun startAudioQueueProcessing() { |
||||
|
audioQueueProcessorThread = Thread { |
||||
|
Log.d(TAG, "音频队列处理线程已启动") |
||||
|
|
||||
|
while (!Thread.currentThread().isInterrupted) { |
||||
|
try { |
||||
|
// 从队列中取出音频数据进行处理 |
||||
|
val audioData = audioDataQueue.take() // 阻塞等待 |
||||
|
|
||||
|
// 将音频数据写入Opus解码流 |
||||
|
opusManager?.writeAudioStream(audioData) |
||||
|
|
||||
|
} catch (e: InterruptedException) { |
||||
|
Log.d(TAG, "音频队列处理线程被中断") |
||||
|
break |
||||
|
} catch (e: Exception) { |
||||
|
Log.e(TAG, "音频队列处理异常: ${e.message}", e) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Log.d(TAG, "音频队列处理线程已停止") |
||||
|
} |
||||
|
|
||||
|
audioQueueProcessorThread?.start() |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,160 @@ |
|||||
|
package com.yunqiinnovation.ble_service |
||||
|
|
||||
|
import android.content.Context |
||||
|
import android.util.Log |
||||
|
import java.io.File |
||||
|
import java.io.FileOutputStream |
||||
|
import java.text.SimpleDateFormat |
||||
|
import java.util.Date |
||||
|
import java.util.Locale |
||||
|
import java.util.concurrent.LinkedBlockingQueue |
||||
|
import java.util.concurrent.atomic.AtomicBoolean |
||||
|
|
||||
|
/** |
||||
|
* 录音文件管理类：负责音频数据的异步写入和文件管理 |
||||
|
*/ |
||||
|
class RecordingFile(private val context: Context) { |
||||
|
private var currentAudioFile: File? = null |
||||
|
private var fos: FileOutputStream? = null |
||||
|
|
||||
|
// 新增：用于异步写入的队列和线程 |
||||
|
private val writeQueue = LinkedBlockingQueue<ByteArray>() |
||||
|
private val isWriting = AtomicBoolean(false) |
||||
|
private var writeThread: Thread? = null |
||||
|
|
||||
|
// 用于存储音频数据的缓冲区 |
||||
|
private val dataBuffer = mutableListOf<ByteArray>() |
||||
|
private var totalBytesWritten = 0 |
||||
|
|
||||
|
var fileName = "" |
||||
|
internal fun creatingFiles() { |
||||
|
if (fos != null || currentAudioFile != null) { |
||||
|
return |
||||
|
} |
||||
|
// 创建新的音频文件 |
||||
|
val dateFormat = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()) |
||||
|
val timestamp = dateFormat.format(Date()) |
||||
|
|
||||
|
val filePath = |
||||
|
File(context.getExternalFilesDir(null), "${fileName}_${timestamp}.txt").absolutePath |
||||
|
currentAudioFile = File(filePath) |
||||
|
currentAudioFile?.createNewFile() |
||||
|
// 追加音频数据到文件 |
||||
|
fos = FileOutputStream(currentAudioFile, true) |
||||
|
startWriteThread() // 新增：启动写入线程 |
||||
|
Log.d("TAG", "创建文件: ${currentAudioFile?.absolutePath}") |
||||
|
} |
||||
|
|
||||
|
// 新增：启动写入线程 |
||||
|
private fun startWriteThread() { |
||||
|
if (isWriting.get()) return |
||||
|
isWriting.set(true) |
||||
|
writeThread = Thread { |
||||
|
try { |
||||
|
while (isWriting.get() || writeQueue.isNotEmpty()) { |
||||
|
val data = writeQueue.poll() ?: continue |
||||
|
fos?.write(data) |
||||
|
} |
||||
|
} catch (e: Exception) { |
||||
|
Log.e("", "异步写入音频数据失败: ${e.message}") |
||||
|
} |
||||
|
} |
||||
|
writeThread?.start() |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 保存音频数据到 opus 文件（异步） |
||||
|
* @param buffer 音频数据字节数组 |
||||
|
*/ |
||||
|
internal fun saveAudioDataToWav(buffer: ByteArray) { |
||||
|
if (fos == null || currentAudioFile == null) return |
||||
|
// 放入队列，由写线程写入 |
||||
|
// // 1. 将字节数据转换为十六进制字符串 |
||||
|
// val hexData = buildString { |
||||
|
// buffer.forEachIndexed { index, byte -> |
||||
|
// append("%02X".format(byte)) |
||||
|
|
||||
|
// } |
||||
|
// } |
||||
|
|
||||
|
// 2. 写入十六进制字符串 |
||||
|
|
||||
|
writeQueue.offer(buffer) |
||||
|
totalBytesWritten += buffer.size |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 保存日志信息到文件（重载方法） |
||||
|
* 使用UTF-8编码处理字符串 |
||||
|
* @param logMessage 日志消息字符串 |
||||
|
*/ |
||||
|
internal fun saveAudioDataToWav(logMessage: String) { |
||||
|
if (fos == null || currentAudioFile == null) return |
||||
|
try { |
||||
|
// 使用UTF-8编码将字符串转换为字节数组，并添加换行符 |
||||
|
val logBytes = (logMessage + "\n").toByteArray(Charsets.UTF_8) |
||||
|
writeQueue.offer(logBytes) |
||||
|
totalBytesWritten += logBytes.size |
||||
|
Log.d("RecordingFile", "保存日志信息: ${logMessage.length} 字符, ${logBytes.size} 字节 (UTF-8)") |
||||
|
} catch (e: Exception) { |
||||
|
Log.e("RecordingFile", "UTF-8编码转换失败: ${e.message}") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* 将音频数据转换为UTF-8编码的十六进制字符串格式并保存 |
||||
|
* @param buffer 音频数据字节数组 |
||||
|
* @param addTimestamp 是否添加时间戳，默认为true |
||||
|
*/ |
||||
|
internal fun saveAudioDataAsUtf8Hex(buffer: ByteArray, addTimestamp: Boolean = true) { |
||||
|
if (fos == null || currentAudioFile == null) return |
||||
|
|
||||
|
try { |
||||
|
val timestamp = if (addTimestamp) { |
||||
|
"[${SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.getDefault()).format(Date())}] " |
||||
|
} else "" |
||||
|
|
||||
|
// 将字节数组转换为十六进制字符串 |
||||
|
val hexString = buffer.joinToString(" ") { "%02X".format(it) } |
||||
|
val dataLine = "${timestamp}音频数据 (${buffer.size} 字节): $hexString\n" |
||||
|
|
||||
|
// 使用UTF-8编码转换为字节数组 |
||||
|
val utf8Bytes = dataLine.toByteArray(Charsets.UTF_8) |
||||
|
writeQueue.offer(utf8Bytes) |
||||
|
totalBytesWritten += utf8Bytes.size |
||||
|
|
||||
|
Log.d("RecordingFile", "保存UTF-8格式音频数据: ${buffer.size} 字节 -> ${utf8Bytes.size} UTF-8字节") |
||||
|
} catch (e: Exception) { |
||||
|
Log.e("RecordingFile", "UTF-8格式保存失败: ${e.message}") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
internal fun closeFile() { |
||||
|
try { |
||||
|
if (fos == null || currentAudioFile == null) { |
||||
|
return |
||||
|
} |
||||
|
isWriting.set(false) |
||||
|
writeThread?.join(500) // 等待写线程结束 |
||||
|
fos?.close() |
||||
|
|
||||
|
// 更新WAV文件头 |
||||
|
currentAudioFile?.let { file -> |
||||
|
// 如果文件小于44字节，直接删除 |
||||
|
if (file.length() <= 0) { |
||||
|
file.delete() |
||||
|
Log.d("TAG", "音频文件过小已删除: ${file.absolutePath}") |
||||
|
} else { |
||||
|
Log.d("TAG", "音频文件保存完成: ${file.absolutePath}") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} catch (e: Exception) { |
||||
|
Log.e("TAG", "更新opus失败: ${e.message}") |
||||
|
} finally { |
||||
|
fos = null |
||||
|
currentAudioFile = null |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue