rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/bt_app/app_fp_rfcomm.cpp
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

777 lines
23 KiB
C++
Raw Blame History

#include "app_fp_rfcomm.h"
#include "app_bt.h"
#include "app_bt_func.h"
#include "app_rfcomm_mgr.h"
#include "app_spp.h"
#include "bt_if.h"
#include "cmsis.h"
#include "cmsis_os.h"
#include "hal_trace.h"
#include "os_api.h"
#include "sdp_api.h"
#include "spp_api.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef IBRT
#include "app_tws_ibrt.h"
#include "app_tws_if.h"
#endif
osMutexDef(fp_rfcomm_mutex);
osMutexDef(fp_rfcomm_credit_mutex);
#define FP_RFCOMM_TX_PKT_CNT 6
/* 128 bit UUID in Big Endian df21fe2c-2515-4fdb-8886-f12c4d67927c */
static const uint8_t FP_RFCOMM_UUID_128[16] = {
0x7C, 0x92, 0x67, 0x4D, 0x2C, 0xF1, 0x86, 0x88,
0xDB, 0x4F, 0x15, 0x25, 0x2C, 0xFE, 0x21, 0xDF};
typedef struct {
uint8_t isConnected;
int8_t serviceIndex;
uint8_t isRfcommInitialized;
} FpRFcommServiceEnv_t;
typedef union {
struct {
uint8_t isCompanionAppInstalled : 1;
uint8_t isSilentModeSupported : 1;
uint8_t reserve : 6;
} env;
uint8_t content;
} FpCapabilitiesEnv_t;
typedef struct {
uint8_t isRightRinging : 1;
uint8_t isLeftRinging : 1;
uint8_t reserve : 6;
} FpRingStatus_t;
static FpRFcommServiceEnv_t fp_rfcomm_service = {false, -1, false};
static FpCapabilitiesEnv_t fp_capabilities = {false, false, 0};
static __attribute__((unused))
FpRingStatus_t fp_ring_status = {false, false, 0};
btif_sdp_record_t *fpSppSdpRecord;
extern "C" void app_gfps_get_battery_levels(uint8_t *pCount,
uint8_t *pBatteryLevel);
extern "C" uint8_t *appm_get_current_ble_addr(void);
static int fp_rfcomm_data_received(void *pDev, uint8_t process, uint8_t *pData,
uint16_t dataLen);
static void app_fp_msg_send_active_components_rsp(void);
static void app_fp_msg_send_message_ack(uint8_t msgGroup, uint8_t msgCode);
static void app_fp_msg_send_message_nak(uint8_t reason, uint8_t msgGroup,
uint8_t msgCode);
static void fp_rfcomm_data_handler(uint8_t *ptr, uint16_t len);
// update this value if the maximum possible tx data size is bigger than current
// value
#define FP_RFCOMM_TX_BUF_CHUNK_SIZE 64
#define FP_RFCOMM_TX_BUF_CHUNK_CNT FP_RFCOMM_TX_PKT_CNT
#define FP_RFCOMM_TX_BUF_SIZE \
(FP_RFCOMM_TX_BUF_CHUNK_CNT * FP_RFCOMM_TX_BUF_CHUNK_SIZE)
static uint32_t fp_rfcomm_tx_buf_next_allocated_chunk = 0;
static uint32_t fp_rfcomm_tx_buf_allocated_chunk_cnt = 0;
static uint8_t fp_rfcomm_tx_buf[FP_RFCOMM_TX_BUF_CHUNK_CNT]
[FP_RFCOMM_TX_BUF_CHUNK_SIZE];
static uint8_t *fp_rfcomm_tx_buf_addr(uint32_t chunk) {
return fp_rfcomm_tx_buf[chunk];
}
static int32_t fp_rfcomm_alloc_tx_chunk(void) {
uint32_t lock = int_lock_global();
if (fp_rfcomm_tx_buf_allocated_chunk_cnt >= FP_RFCOMM_TX_BUF_CHUNK_CNT) {
int_unlock_global(lock);
return -1;
}
uint32_t returnedChunk = fp_rfcomm_tx_buf_next_allocated_chunk;
fp_rfcomm_tx_buf_allocated_chunk_cnt++;
fp_rfcomm_tx_buf_next_allocated_chunk++;
if (FP_RFCOMM_TX_BUF_CHUNK_CNT == fp_rfcomm_tx_buf_next_allocated_chunk) {
fp_rfcomm_tx_buf_next_allocated_chunk = 0;
}
int_unlock_global(lock);
return returnedChunk;
}
static bool fp_rfcomm_free_tx_chunk(void) {
uint32_t lock = int_lock_global();
if (0 == fp_rfcomm_tx_buf_allocated_chunk_cnt) {
int_unlock_global(lock);
return false;
}
fp_rfcomm_tx_buf_allocated_chunk_cnt--;
int_unlock_global(lock);
return true;
}
static void fp_rfcomm_reset_tx_buf(void) {
uint32_t lock = int_lock_global();
fp_rfcomm_tx_buf_allocated_chunk_cnt = 0;
fp_rfcomm_tx_buf_next_allocated_chunk = 0;
int_unlock_global(lock);
}
#define GFPS_FIND_MY_BUDS_CMD_STOP 0x0
#define GFPS_FIND_MY_BUDS_CMD_START 0x1
#define FIND_MY_BUDS_CMD_STOP_MASTER 0x00
#define FIND_MY_BUDS_CMD_STOP_SLAVE 0x01
#define FIND_MY_BUDS_CMD_START_MASTER 0x10
#define FIND_MY_BUDS_CMD_START_SLAVE 0x11
#define FIND_MY_BUDS_STATUS_SLAVE_MASK 0x1
#define FIND_MY_BUDS_STATUS_MASTER_MASK 0x2
uint8_t find_buds_flag = 0;
#include "app_status_ind.h"
#include "apps.h"
void app_set_find_my_buds(uint8_t mode) {
#ifdef IBRT
ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
TRACE(2, "%s, mode = %d,role = %d", __func__, mode,
p_ibrt_ctrl->current_role);
switch (mode) {
case FIND_MY_BUDS_CMD_STOP_MASTER:
if (find_buds_flag & FIND_MY_BUDS_STATUS_MASTER_MASK) {
/* stop beeping master */
if (IBRT_SLAVE != p_ibrt_ctrl->current_role) {
// app_set_find_my_buds_status(false);
app_voice_stop(APP_STATUS_INDICATION_FIND_MY_BUDS, 0);
find_buds_flag &= ~(FIND_MY_BUDS_STATUS_MASTER_MASK);
}
}
break;
case FIND_MY_BUDS_CMD_STOP_SLAVE:
if (find_buds_flag & FIND_MY_BUDS_STATUS_SLAVE_MASK) {
/* stop beeping slave */
if (IBRT_SLAVE == p_ibrt_ctrl->current_role) {
app_voice_stop(APP_STATUS_INDICATION_FIND_MY_BUDS, 0);
find_buds_flag &= ~(FIND_MY_BUDS_STATUS_SLAVE_MASK);
}
}
break;
case FIND_MY_BUDS_CMD_START_MASTER:
if (!(find_buds_flag & FIND_MY_BUDS_STATUS_MASTER_MASK)) {
/* start beep master */
if (IBRT_SLAVE != p_ibrt_ctrl->current_role) {
app_voice_report(APP_STATUS_INDICATION_FIND_MY_BUDS, 0);
find_buds_flag |= FIND_MY_BUDS_STATUS_MASTER_MASK;
}
}
break;
case FIND_MY_BUDS_CMD_START_SLAVE:
if (!(find_buds_flag & FIND_MY_BUDS_STATUS_SLAVE_MASK)) {
/* start beep slave */
if (IBRT_SLAVE == p_ibrt_ctrl->current_role) {
app_voice_report(APP_STATUS_INDICATION_FIND_MY_BUDS, 0);
find_buds_flag |= FIND_MY_BUDS_STATUS_SLAVE_MASK;
}
}
break;
default:
break;
}
#else
switch (mode) {
case GFPS_FIND_MY_BUDS_CMD_START:
app_voice_report(APP_STATUS_INDICATION_FIND_MY_BUDS, 0);
break;
case GFPS_FIND_MY_BUDS_CMD_STOP:
app_voice_stop(APP_STATUS_INDICATION_FIND_MY_BUDS, 0);
default:
break;
}
#endif
}
osTimerId ring_timeout_timer_id = NULL;
static void gfps_find_devices_ring_timeout_handler(void const *param);
osTimerDef(GFPS_FIND_DEVICES_RING_TIMEOUT,
gfps_find_devices_ring_timeout_handler);
#define GFPS_FIND_MY_BUDS_CMD_STOP_DUAL 0x0
#define GFPS_FIND_MY_BUDS_CMD_START_MASTER_ONLY 0x1
#define GFPS_FIND_MY_BUDS_CMD_START_SLAVE_ONLY 0x2
#define GFPS_FIND_MY_BUDS_CMD_START_DUAL 0x3
static void gfps_set_find_my_buds(uint8_t cmd) {
TRACE(2, "%s, cmd = %d", __func__, cmd);
#ifdef IBRT
if (GFPS_FIND_MY_BUDS_CMD_STOP_DUAL == cmd) {
app_set_find_my_buds(FIND_MY_BUDS_CMD_STOP_MASTER);
app_set_find_my_buds(FIND_MY_BUDS_CMD_STOP_SLAVE);
} else if (GFPS_FIND_MY_BUDS_CMD_START_MASTER_ONLY ==
cmd) // right ring, stop left
{
app_set_find_my_buds(FIND_MY_BUDS_CMD_STOP_SLAVE);
app_set_find_my_buds(FIND_MY_BUDS_CMD_START_MASTER);
} else if (GFPS_FIND_MY_BUDS_CMD_START_SLAVE_ONLY ==
cmd) // left ring, stop right
{
app_set_find_my_buds(FIND_MY_BUDS_CMD_STOP_MASTER);
app_set_find_my_buds(FIND_MY_BUDS_CMD_START_SLAVE);
} else if (GFPS_FIND_MY_BUDS_CMD_START_DUAL == cmd) // both ring
{
app_set_find_my_buds(FIND_MY_BUDS_CMD_START_MASTER);
app_set_find_my_buds(FIND_MY_BUDS_CMD_START_SLAVE);
}
#else
app_set_find_my_buds(cmd);
#endif
}
static void gfps_find_devices_ring_timeout_handler(void const *param) {
TRACE(0, "gfps_find_devices_ring_timeout_handler");
app_bt_start_custom_function_in_bt_thread(GFPS_FIND_MY_BUDS_CMD_STOP_DUAL, 0,
(uint32_t)gfps_set_find_my_buds);
}
void fp_rfcomm_ring_timer_set(uint8_t period) {
TRACE(2, "%s, period = %d", __func__, period);
if (ring_timeout_timer_id == NULL) {
ring_timeout_timer_id = osTimerCreate(
osTimer(GFPS_FIND_DEVICES_RING_TIMEOUT), osTimerOnce, NULL);
}
osTimerStop(ring_timeout_timer_id);
if (period) {
osTimerStart(ring_timeout_timer_id, period * 1000);
}
}
static void fp_rfcomm_ring_request_handling(uint8_t *requestdata,
uint16_t datalen) {
TRACE(1, "%s,[RFCOMM][FMD] request", __func__);
DUMP8("%02x ", requestdata, datalen);
app_fp_msg_send_message_ack(FP_MSG_GROUP_DEVICE_ACTION,
FP_MSG_DEVICE_ACTION_RING);
if (datalen > 1) {
fp_rfcomm_ring_timer_set(requestdata[1]);
}
gfps_set_find_my_buds(requestdata[0]);
// TODO: implement the continuous audio prompt playing state machine
#if 0
uint8_t isAllowed = false;
uint8_t isChangePeerDevStatus = false;
switch (request)
{
case 3:
{
if (IS_CONNECTED_WITH_TWS() &&
((0 == fp_ring_status.isLeftRinging) &&
(0 == fp_ring_status.isRightRinging)))
{
// TODO: start ringing on both sides
fp_ring_status.isLeftRinging = true;
fp_ring_status.isRightRinging = true;
isAllowed = true;
}
break;
}
case 1:
if (0 == fp_ring_status.isRightRinging)
{
if (((fp_ring_status.isLeftRinging) && app_tws_is_right_side()) ||
app_tws_is_left_side())
{
isChangePeerDevStatus = true;
}
if (isChangePeerDevStatus && !IS_CONNECTED_WITH_TWS())
{
break;
}
// start right ring
if (app_tws_is_left_side())
{
// TODO: start ringing on peer device
}
else if (app_tws_is_right_side())
{
// TODO: start local ringing
}
if (fp_ring_status.isLeftRinging)
{
// stop left ring
if (app_tws_is_right_side())
{
// TODO: stop ringing on peer device
}
else if (app_tws_is_left_side())
{
// TODO: stop local ringing
}
}
fp_ring_status.isLeftRinging = false;
fp_ring_status.isRightRinging = true;
isAllowed = true;
}
break;
case 2:
if (0 == fp_ring_status.isLeftRinging)
{
if (((fp_ring_status.isRightRinging) && app_tws_is_left_side()) ||
app_tws_is_right_side())
{
isChangePeerDevStatus = true;
}
if (isChangePeerDevStatus && !IS_CONNECTED_WITH_TWS())
{
break;
}
// start left ring
if (app_tws_is_right_side())
{
// TODO: start ringing on peer device
}
else if (app_tws_is_left_side())
{
// TODO: start local ringing
}
if (fp_ring_status.isRightRinging)
{
// stop left ring
if (app_tws_is_left_side())
{
// TODO: stop ringing on peer device
}
else if (app_tws_is_right_side())
{
// TODO: stop local ringing
}
}
fp_ring_status.isLeftRinging = true;
fp_ring_status.isRightRinging = false;
isAllowed = true;
}
break;
case 0:
if (IS_CONNECTED_WITH_TWS() &&
((1 == fp_ring_status.isLeftRinging) &&
(1 == fp_ring_status.isRightRinging)))
{
// TODO: stop ringing on both sides
fp_ring_status.isLeftRinging = false;
fp_ring_status.isRightRinging = false;
isAllowed = true;
}
else
{
if (((fp_ring_status.isLeftRinging) && app_tws_is_right_side()) ||
((fp_ring_status.isRightRinging) && app_tws_is_left_side()))
{
isChangePeerDevStatus = true;
}
if (isChangePeerDevStatus && !IS_CONNECTED_WITH_TWS())
{
break;
}
// stop right ring
if (fp_ring_status.isRightRinging)
{
if (app_tws_is_left_side())
{
// TODO: stop ringing on peer device
}
else if (app_tws_is_right_side())
{
// TODO: stop local ringing
}
}
if (fp_ring_status.isLeftRinging)
{
// stop left ring
if (app_tws_is_right_side())
{
// TODO: stop ringing on peer device
}
else if (app_tws_is_left_side())
{
// TODO: stop local ringing
}
}
fp_ring_status.isLeftRinging = false;
fp_ring_status.isRightRinging = false;
isAllowed = true;
}
break;
default:
isAllowed = false;
break;
}
if (isAllowed)
{
app_fp_msg_send_message_ack(FP_MSG_GROUP_DEVICE_ACTION, FP_MSG_DEVICE_ACTION_RING);
}
else
{
app_fp_msg_send_message_nak(FP_MSG_NAK_REASON_NOT_ALLOWED,
FP_MSG_GROUP_DEVICE_ACTION, FP_MSG_DEVICE_ACTION_RING);
}
#endif
}
#define FP_ACCUMULATED_DATA_BUF_SIZE 128
static uint8_t fp_accumulated_data_buf[FP_ACCUMULATED_DATA_BUF_SIZE];
static uint16_t fp_accumulated_data_size = 0;
static void fp_rfcomm_reset_data_accumulator(void) {
fp_accumulated_data_size = 0;
memset(fp_accumulated_data_buf, 0, sizeof(fp_accumulated_data_buf));
}
static void fp_rfcomm_data_accumulator(uint8_t *ptr, uint16_t len) {
ASSERT((fp_accumulated_data_size + len) < sizeof(fp_accumulated_data_buf),
"fp accumulcate buffer is overflow!");
memcpy(&fp_accumulated_data_buf[fp_accumulated_data_size], ptr, len);
fp_accumulated_data_size += len;
uint16_t msgTotalLen;
FP_MESSAGE_STREAM_T *msgStream;
while (fp_accumulated_data_size >= FP_MESSAGE_RESERVED_LEN) {
msgStream = (FP_MESSAGE_STREAM_T *)fp_accumulated_data_buf;
msgTotalLen =
((msgStream->dataLenHighByte << 8) | msgStream->dataLenLowByte) +
FP_MESSAGE_RESERVED_LEN;
ASSERT(msgTotalLen < sizeof(fp_accumulated_data_buf),
"Wrong fp msg len %d received!", msgTotalLen);
if (fp_accumulated_data_size >= msgTotalLen) {
fp_rfcomm_data_handler(fp_accumulated_data_buf, msgTotalLen);
fp_accumulated_data_size -= msgTotalLen;
memmove(fp_accumulated_data_buf, &fp_accumulated_data_buf[msgTotalLen],
fp_accumulated_data_size);
} else {
break;
}
}
}
static void fp_rfcomm_data_handler(uint8_t *ptr, uint16_t len) {
FP_MESSAGE_STREAM_T *pMsg = (FP_MESSAGE_STREAM_T *)ptr;
uint16_t datalen = 0;
TRACE(2, "fp rfcomm receives msg group %d code %d", pMsg->messageGroup,
pMsg->messageCode);
switch (pMsg->messageGroup) {
case FP_MSG_GROUP_DEVICE_INFO: {
switch (pMsg->messageCode) {
case FP_MSG_DEVICE_INFO_ACTIVE_COMPONENTS_REQ:
app_fp_msg_send_active_components_rsp();
break;
case FP_MSG_DEVICE_INFO_TELL_CAPABILITIES:
fp_capabilities.content = pMsg->data[0];
TRACE(3, "cap 0x%x isCompanionAppInstalled %d isSilentModeSupported %d",
fp_capabilities.content,
fp_capabilities.env.isCompanionAppInstalled,
fp_capabilities.env.isSilentModeSupported);
break;
default:
break;
}
}
case FP_MSG_GROUP_DEVICE_ACTION: {
switch (pMsg->messageCode) {
case FP_MSG_DEVICE_ACTION_RING:
datalen = (pMsg->dataLenHighByte << 8) + pMsg->dataLenLowByte;
fp_rfcomm_ring_request_handling(pMsg->data, datalen);
break;
default:
break;
}
break;
}
default:
break;
}
}
static int fp_rfcomm_data_received(void *pDev, uint8_t process, uint8_t *pData,
uint16_t dataLen) {
TRACE(1, "%s", __func__);
// DUMP8("0x%02x ",pData, dataLen);
fp_rfcomm_data_accumulator(pData, dataLen);
return 0;
}
static void fp_rfcomm_connected_handler(void) {
if (!fp_rfcomm_service.isConnected) {
fp_rfcomm_service.isConnected = true;
fp_rfcomm_reset_data_accumulator();
app_fp_msg_send_model_id();
app_fp_msg_send_updated_ble_addr();
app_fp_msg_send_battery_levels();
}
}
static bool fp_rfcomm_callback(RFCOMM_EVENT_E event, uint8_t instanceIndex,
uint16_t connHandle, uint8_t *pBtAddr,
uint8_t *pSentDataBuf, uint16_t sentDataLen) {
TRACE(2, "%s,event is %d", __func__, event);
switch (event) {
case RFCOMM_INCOMING_CONN_REQ: {
TRACE(0, "Connected Indication RFComm device info:");
TRACE(2, "hci handle is 0x%x service index %d", connHandle, instanceIndex);
if (pBtAddr) {
TRACE(0, "Bd addr is:");
DUMP8("%02x ", pBtAddr, 6);
}
fp_rfcomm_connected_handler();
break;
}
case RFCOMM_CONNECTED: {
if (pBtAddr) {
TRACE(0, "Bd addr is:");
DUMP8("%02x ", pBtAddr, 6);
}
fp_rfcomm_connected_handler();
break;
}
case RFCOMM_DISCONNECTED: {
TRACE(0, "Disconnected Rfcomm device info:");
TRACE(0, "Bd addr is:");
DUMP8("%02x ", pBtAddr, 6);
TRACE(1, "hci handle is 0x%x", connHandle);
TRACE(1, "::RFCOMM_DISCONNECTED %d", event);
fp_rfcomm_service.isConnected = false;
fp_rfcomm_reset_tx_buf();
break;
}
case RFCOMM_TX_DONE: {
TRACE(1, "Rfcomm dataLen %d sent out", sentDataLen);
fp_rfcomm_free_tx_chunk();
break;
}
default: {
TRACE(1, "Unkown rfcomm event %d", event);
break;
}
}
return true;
}
static void app_fp_disconnect_rfcomm_handler(void) {
if (fp_rfcomm_service.isConnected) {
app_rfcomm_close(fp_rfcomm_service.serviceIndex);
}
}
void app_fp_disconnect_rfcomm(void) {
app_bt_start_custom_function_in_bt_thread(
0, 0, (uint32_t)app_fp_disconnect_rfcomm_handler);
}
static void app_fp_rfcomm_send_handler(uint8_t *ptrData, uint32_t length) {
int8_t ret =
app_rfcomm_write(fp_rfcomm_service.serviceIndex, ptrData, length);
if (0 != ret) {
fp_rfcomm_free_tx_chunk();
}
}
void app_fp_rfcomm_send(uint8_t *ptrData, uint32_t length) {
if (!fp_rfcomm_service.isConnected) {
return;
}
int32_t chunk = fp_rfcomm_alloc_tx_chunk();
if (-1 == chunk) {
TRACE(0, "Fast pair rfcomm tx buffer used out!");
return;
}
ASSERT(length < FP_RFCOMM_TX_BUF_CHUNK_SIZE,
"FP_RFCOMM_TX_BUF_CHUNK_SIZE is %d which is smaller than %d, need to "
"increase!",
FP_RFCOMM_TX_BUF_CHUNK_SIZE, length);
uint8_t *txBufAddr = fp_rfcomm_tx_buf_addr(chunk);
memcpy(txBufAddr, ptrData, length);
app_bt_start_custom_function_in_bt_thread(
(uint32_t)txBufAddr, (uint32_t)length,
(uint32_t)app_fp_rfcomm_send_handler);
}
bt_status_t app_fp_rfcomm_init(void) {
TRACE(1, "%s", __func__);
bt_status_t stat = BT_STS_SUCCESS;
if (!fp_rfcomm_service.isRfcommInitialized) {
osMutexId mid;
mid = osMutexCreate(osMutex(fp_rfcomm_mutex));
if (!mid) {
ASSERT(0, "cannot create mutex");
}
fp_rfcomm_service.isRfcommInitialized = true;
RFCOMM_CONFIG_T tConfig;
tConfig.callback = fp_rfcomm_callback;
tConfig.tx_pkt_cnt = FP_RFCOMM_TX_PKT_CNT;
tConfig.rfcomm_128bit_uuid = FP_RFCOMM_UUID_128;
tConfig.rfcomm_ch = RFCOMM_CHANNEL_FP;
tConfig.app_id = BTIF_APP_SPP_SERVER_FP_RFCOMM_ID;
tConfig.spp_handle_data_event_func = fp_rfcomm_data_received;
tConfig.mutexId = mid;
tConfig.creditMutexId = osMutexCreate(osMutex(fp_rfcomm_credit_mutex));
int8_t index = app_rfcomm_open(&tConfig);
if (-1 == index) {
TRACE(0, "fast pair rfcomm open failed");
return BT_STS_FAILED;
}
fp_rfcomm_service.isConnected = false;
fp_rfcomm_service.serviceIndex = index;
} else {
TRACE(0, "already initialized.");
}
return stat;
}
bool app_is_fp_rfcomm_connected(void) { return fp_rfcomm_service.isConnected; }
// use cases for fp message stream
void app_fp_msg_enable_bt_silence_mode(bool isEnable) {
if (fp_capabilities.env.isSilentModeSupported) {
FP_MESSAGE_STREAM_T req = {FP_MSG_GROUP_BLUETOOTH_EVENT, 0, 0, 0};
if (isEnable) {
req.messageCode = FP_MSG_BT_EVENT_ENABLE_SILENCE_MODE;
} else {
req.messageCode = FP_MSG_BT_EVENT_DISABLE_SILENCE_MODE;
}
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN);
} else {
TRACE(0, "fp silence mode is not supported.");
}
}
void app_fp_msg_send_model_id(void) {
TRACE(1, "%s", __func__);
#ifndef IS_USE_CUSTOM_FP_INFO
uint32_t model_id = 0x2B677D;
#else
uint32_t model_id = app_bt_get_model_id();
#endif
uint8_t modelID[3];
modelID[0] = (model_id >> 16) & 0xFF;
modelID[1] = (model_id >> 8) & 0xFF;
modelID[2] = (model_id)&0xFF;
uint16_t rawDataLen = sizeof(modelID);
FP_MESSAGE_STREAM_T req = {
FP_MSG_GROUP_DEVICE_INFO, FP_MSG_DEVICE_INFO_MODEL_ID,
(uint8_t)(rawDataLen >> 8), (uint8_t)(rawDataLen & 0xFF)};
memcpy(req.data, modelID, sizeof(modelID));
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN + rawDataLen);
}
void app_fp_msg_send_updated_ble_addr(void) {
FP_MESSAGE_STREAM_T req = {FP_MSG_GROUP_DEVICE_INFO,
FP_MSG_DEVICE_INFO_BLE_ADD_UPDATED, 0, 6};
uint8_t *ptr = appm_get_current_ble_addr();
for (uint8_t index = 0; index < 6; index++) {
req.data[index] = ptr[5 - index];
}
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN + 6);
}
void app_fp_msg_send_battery_levels(void) {
TRACE(1, "%s", __func__);
FP_MESSAGE_STREAM_T req = {FP_MSG_GROUP_DEVICE_INFO,
FP_MSG_DEVICE_INFO_BATTERY_UPDATED, 0, 3};
uint8_t batteryLevelCount = 0;
app_gfps_get_battery_levels(&batteryLevelCount, req.data);
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN + 3);
}
static __attribute__((unused)) void
app_fp_msg_send_active_components_rsp(void) {
FP_MESSAGE_STREAM_T req = {FP_MSG_GROUP_DEVICE_INFO,
FP_MSG_DEVICE_INFO_ACTIVE_COMPONENTS_RSP, 0, 1};
#if defined(IBRT)
if (app_tws_ibrt_tws_link_connected()) {
req.data[0] = FP_MSG_BOTH_BUDS_ACTIVE;
} else {
if (app_tws_is_left_side()) {
req.data[0] = FP_MSG_LEFT_BUD_ACTIVE;
} else {
req.data[0] = FP_MSG_RIGHT_BUD_ACTIVE;
}
}
#else
req.data[0] = FP_MSG_BOTH_BUDS_ACTIVE;
#endif
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN + 1);
}
static __attribute__((unused)) void
app_fp_msg_send_message_ack(uint8_t msgGroup, uint8_t msgCode) {
FP_MESSAGE_STREAM_T req = {FP_MSG_GROUP_ACKNOWLEDGEMENT, FP_MSG_ACK, 0, 2};
req.data[0] = msgGroup;
req.data[1] = msgCode;
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN + 2);
}
static __attribute__((unused)) void
app_fp_msg_send_message_nak(uint8_t reason, uint8_t msgGroup, uint8_t msgCode) {
FP_MESSAGE_STREAM_T req = {FP_MSG_GROUP_ACKNOWLEDGEMENT, FP_MSG_NAK, 0, 3};
req.data[0] = reason;
req.data[1] = msgGroup;
req.data[2] = msgCode;
app_fp_rfcomm_send((uint8_t *)&req, FP_MESSAGE_RESERVED_LEN + 3);
}
Reference in a new issue View git blame Copy permalink