rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/ble_app/app_main/app_ble_mode_switch.c
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

1068 lines
29 KiB
C
Raw Blame History

/***************************************************************************
*
*Copyright 2015-2019 BES.
*All rights reserved. All unpublished rights reserved.
*
*No part of this work may be used or reproduced in any form or by any
*means, or stored in a database or retrieval system, without prior written
*permission of BES.
*
*Use of this work is governed by a license granted by BES.
*This work contains confidential and proprietary information of
*BES. which is protected by copyright, trade secret,
*trademark and other intellectual property rights.
*
****************************************************************************/
/*****************************header include********************************/
#include "app.h"
#include "app_ble_include.h"
#include "app_bt.h"
#include "app_bt_func.h"
#include "app_hfp.h"
#include "app_sec.h"
#include "app_thread.h"
#include "app_utils.h"
#include "apps.h"
#include "ble_app_dbg.h"
#include "cmsis_os.h"
#include "co_math.h" // Common Maths Definition
#include "hal_timer.h"
#include "nvrecord.h"
#include "nvrecord_ble.h"
#include "rwprf_config.h"
#include "stdbool.h"
#include "string.h"
/************************private macro defination***************************/
#define DEBUG_BLE_STATE_MACHINE true
#if DEBUG_BLE_STATE_MACHINE
#define SET_BLE_STATE(newState) \
do { \
LOG_I("[STATE]%s->%s at line %d", ble_state2str(bleModeEnv.state), \
ble_state2str(newState), __LINE__); \
bleModeEnv.state = (newState); \
} while (0);
#define SET_BLE_OP(newOp) \
do { \
LOG_I("[OP]%s->%s at line %d", ble_op2str(bleModeEnv.op), \
ble_op2str(newOp), __LINE__); \
bleModeEnv.op = (newOp); \
} while (0);
#else
#define SET_BLE_STATE(newState) \
do { \
bleModeEnv.state = (newState); \
} while (0);
#define SET_BLE_OP(newOp) \
do { \
bleModeEnv.op = (newOp); \
} while (0);
#endif
extern void bt_drv_reg_op_set_rand_seed(uint32_t seed);
/************************private type defination****************************/
/************************extern function declearation***********************/
extern uint8_t bt_addr[6];
/**********************private function declearation************************/
/*---------------------------------------------------------------------------
* ble_state2str
*---------------------------------------------------------------------------
*
*Synopsis:
* get the string of the ble state
*
* Parameters:
* state - state to get string
*
* Return:
* the string of the BLE state
*/
static char *ble_state2str(uint8_t state);
/*---------------------------------------------------------------------------
* ble_op2str
*---------------------------------------------------------------------------
*
*Synopsis:
* get the string of the ble operation
*
* Parameters:
* op - operation to get string
*
* Return:
* the string of the BLE operation
*/
static char *ble_op2str(uint8_t op);
/*---------------------------------------------------------------------------
* ble_adv_user2str
*---------------------------------------------------------------------------
*
*Synopsis:
* get the string of the ble_adv_user
*
* Parameters:
* op - operation to get string
*
* Return:
* the string of the ble_adv_user
*/
static char *ble_adv_user2str(enum BLE_ADV_USER_E user);
/*---------------------------------------------------------------------------
* ble_adv_config_param
*---------------------------------------------------------------------------
*
*Synopsis:
* configure BLE adv related parameter in @advParam for further use
*
* Parameters:
* advType - advertisment mode, see @ for more info
* advInterval - advertisement interval in MS
*
* Return:
* void
*/
static void ble_adv_config_param(uint8_t advType, uint16_t advInterval);
/*---------------------------------------------------------------------------
* ble_adv_is_allowed
*---------------------------------------------------------------------------
*
*Synopsis:
* check if BLE advertisment is allowed or not
*
* Parameters:
* void
*
* Return:
* true - if advertisement is allowed
* flase - if adverstisement is not allowed
*/
static bool ble_adv_is_allowed(void);
/*---------------------------------------------------------------------------
* ble_start_adv
*---------------------------------------------------------------------------
*
*Synopsis:
* start BLE advertisement
*
* Parameters:
* param - see @BLE_ADV_PARAM_T to get more info
*
* Return:
* void
*/
static void ble_start_adv(void *param);
/*---------------------------------------------------------------------------
* ble_start_adv_failed_cb
*---------------------------------------------------------------------------
*
*Synopsis:
* callback function of start BLE advertisement failed
*
* Parameters:
* void
*
* Return:
* void
*/
static void ble_start_adv_failed_cb(void);
/*---------------------------------------------------------------------------
* ble_start_scan
*---------------------------------------------------------------------------
*
*Synopsis:
* start BLE scan api
*
* Parameters:
* param - see @BLE_SCAN_PARAM_T to get more info
*
* Return:
* void
*/
static void ble_start_scan(void *param);
/*---------------------------------------------------------------------------
* ble_start_connect
*---------------------------------------------------------------------------
*
*Synopsis:
* start BLE connection
*
* Parameters:
* bleBdAddr - address of BLE device to connect
*
* Return:
* void
*/
static void ble_start_connect(uint8_t *bleBdAddr);
/*---------------------------------------------------------------------------
* ble_stop_all_activities
*---------------------------------------------------------------------------
*
*Synopsis:
* stop all BLE pending operations, stop ongoing adv and scan
* NOTE: will not disconnect BLE connections
*
* Parameters:
* void
*
* Return:
* void
*/
static void ble_stop_all_activities(void);
/*---------------------------------------------------------------------------
* ble_execute_pending_op
*---------------------------------------------------------------------------
*
*Synopsis:
* execute pended BLE op
*
* Parameters:
* void
*
* Return:
* void
*/
static void ble_execute_pending_op(void);
/*---------------------------------------------------------------------------
* ble_switch_activities
*---------------------------------------------------------------------------
*
*Synopsis:
* switch BLE activities after last state complete
*
* Parameters:
* void
*
* Return:
* void
*/
static void ble_switch_activities(void);
/************************private variable defination************************/
static BLE_MODE_ENV_T bleModeEnv;
static BLE_ADV_PARAM_T advParam;
static BLE_SCAN_PARAM_T scanParam;
/****************************function defination****************************/
// common used function
#ifdef USE_LOG_I_ID
static inline char *ble_state2str(uint8_t state) {
return (char *)(uint32_t)state;
}
static inline char *ble_op2str(uint8_t op) { return (char *)(uint32_t)op; }
static inline char *ble_adv_user2str(enum BLE_ADV_USER_E user) {
return (char *)(uint32_t)user;
}
#else
static char *ble_state2str(uint8_t state) {
char *str = NULL;
#define CASES(state) \
case state: \
str = "[" #state "]"; \
break
switch (state) {
CASES(STATE_IDLE);
CASES(ADVERTISING);
CASES(STARTING_ADV);
CASES(STOPPING_ADV);
CASES(SCANNING);
CASES(STARTING_SCAN);
CASES(STOPPING_SCAN);
CASES(CONNECTING);
CASES(STARTING_CONNECT);
CASES(STOPPING_CONNECT);
default:
str = "[INVALID]";
break;
}
return str;
}
static char *ble_op2str(uint8_t op) {
char *str = NULL;
#define CASEO(op) \
case op: \
str = "[" #op "]"; \
break
switch (op) {
CASEO(OP_IDLE);
CASEO(START_ADV);
CASEO(START_SCAN);
CASEO(START_CONNECT);
CASEO(STOP_ADV);
CASEO(STOP_SCAN);
CASEO(STOP_CONNECT);
default:
str = "[INVALID]";
break;
}
return str;
}
static char *ble_adv_user2str(enum BLE_ADV_USER_E user) {
#define CASE_S(s) \
case s: \
return "[" #s "]";
#define CASE_D() \
default: \
return "[INVALID]";
switch (user) {
CASE_S(USER_STUB)
CASE_S(USER_GFPS)
CASE_S(USER_GSOUND)
CASE_S(USER_AI)
CASE_S(USER_INTERCONNECTION)
CASE_S(USER_TILE)
CASE_S(USER_OTA)
CASE_D()
}
}
#endif
void app_ble_mode_init(void) {
LOG_I("%s", __func__);
memset(&bleModeEnv, 0, sizeof(bleModeEnv));
SET_BLE_STATE(STATE_IDLE);
SET_BLE_OP(OP_IDLE);
bleModeEnv.bleEnv = &app_env;
}
// ble advertisement used functions
static void ble_adv_config_param(uint8_t advType, uint16_t advInterval) {
uint8_t avail_space;
memset(&advParam, 0, sizeof(advParam));
advParam.advType = advType;
advParam.advInterval = advInterval;
advParam.withFlag = true;
// connectable adv is not allowed if max connection reaches
if (app_is_arrive_at_max_ble_connections() &&
(GAPM_ADV_UNDIRECT == advType)) {
LOG_W("will change adv type to none-connectable because max ble connection "
"reaches");
advParam.advType = GAPM_ADV_NON_CONN;
}
for (uint8_t user = 0; user < BLE_ADV_USER_NUM; user++) {
if (bleModeEnv.bleDataFillFunc[user]) {
bleModeEnv.bleDataFillFunc[user]((void *)&advParam);
// check if the adv/scan_rsp data length is legal
if (advParam.withFlag) {
ASSERT(BLE_ADV_DATA_WITH_FLAG_LEN >= advParam.advDataLen,
"[BLE][ADV]adv data exceed");
} else {
ASSERT(BLE_ADV_DATA_WITHOUT_FLAG_LEN >= advParam.advDataLen,
"[BLE][ADV]adv data exceed");
}
ASSERT(SCAN_RSP_DATA_LEN >= advParam.scanRspDataLen,
"[BLE][ADV]scan response data exceed");
}
}
if (advParam.withFlag) {
avail_space = BLE_ADV_DATA_WITH_FLAG_LEN - advParam.advDataLen -
BLE_ADV_DATA_STRUCT_HEADER_LEN;
} else {
avail_space = BLE_ADV_DATA_WITHOUT_FLAG_LEN - advParam.advDataLen -
BLE_ADV_DATA_STRUCT_HEADER_LEN;
}
// Check if data can be added to the adv Data
if (avail_space > 2) {
avail_space = co_min(avail_space, bleModeEnv.bleEnv->dev_name_len);
advParam.advData[advParam.advDataLen++] = avail_space + 1;
// Fill Device Name Flag
advParam.advData[advParam.advDataLen++] =
(avail_space == bleModeEnv.bleEnv->dev_name_len) ? '\x08' : '\x09';
// Copy device name
memcpy(&advParam.advData[advParam.advDataLen], bleModeEnv.bleEnv->dev_name,
avail_space);
// Update adv Data Length
advParam.advDataLen += avail_space;
}
}
static bool ble_adv_is_allowed(void) {
bool allowed_adv = true;
if (!app_is_stack_ready()) {
LOG_I("reason: stack not ready");
allowed_adv = false;
}
if (app_is_power_off_in_progress()) {
LOG_I("reason: in power off mode");
allowed_adv = false;
}
if (bleModeEnv.advSwitch) {
LOG_I("adv switched off:%d", bleModeEnv.advSwitch);
allowed_adv = false;
}
if (btapp_hfp_is_sco_active()) {
LOG_I("SCO ongoing");
allowed_adv = false;
}
if (false == allowed_adv) {
app_ble_stop_activities();
}
return allowed_adv;
}
static void ble_start_adv(void *param) {
switch (bleModeEnv.state) {
case ADVERTISING:
SET_BLE_STATE(STOPPING_ADV);
SET_BLE_OP(START_ADV);
appm_stop_advertising();
break;
case SCANNING:
SET_BLE_STATE(STOPPING_SCAN);
SET_BLE_OP(START_ADV);
appm_stop_scanning();
break;
case CONNECTING:
SET_BLE_STATE(STOPPING_CONNECT);
SET_BLE_OP(START_ADV);
appm_stop_connecting();
break;
case STARTING_ADV:
case STARTING_SCAN:
case STARTING_CONNECT:
case STOPPING_ADV:
case STOPPING_SCAN:
case STOPPING_CONNECT:
SET_BLE_OP(START_ADV);
break;
case STATE_IDLE:
if (!ble_adv_is_allowed()) {
LOG_I("[ADV] not allowed.");
if (START_ADV == bleModeEnv.op) {
SET_BLE_OP(OP_IDLE);
}
break;
}
memcpy(&bleModeEnv.advInfo, param, sizeof(bleModeEnv.advInfo));
appm_start_advertising(&bleModeEnv.advInfo);
SET_BLE_STATE(STARTING_ADV);
break;
default:
break;
}
}
static void ble_start_adv_failed_cb(void) {
if (STARTING_ADV == bleModeEnv.state) {
SET_BLE_STATE(STATE_IDLE);
}
// start pending op(start adv again)
}
static void ble_start_scan(void *param) {
switch (bleModeEnv.state) {
case ADVERTISING:
SET_BLE_STATE(STOPPING_ADV);
SET_BLE_OP(START_SCAN);
appm_stop_advertising();
break;
case SCANNING:
SET_BLE_STATE(STOPPING_SCAN);
SET_BLE_OP(START_SCAN);
appm_stop_scanning();
break;
case CONNECTING:
SET_BLE_STATE(STOPPING_CONNECT);
SET_BLE_OP(START_SCAN);
appm_stop_connecting();
break;
case STARTING_ADV:
case STARTING_SCAN:
case STARTING_CONNECT:
case STOPPING_ADV:
case STOPPING_SCAN:
case STOPPING_CONNECT:
SET_BLE_OP(START_SCAN);
break;
case STATE_IDLE:
SET_BLE_STATE(STARTING_SCAN);
memcpy(&bleModeEnv.scanInfo, param, sizeof(BLE_SCAN_PARAM_T));
appm_start_scanning(bleModeEnv.scanInfo.scanInterval,
bleModeEnv.scanInfo.scanWindow,
bleModeEnv.scanInfo.scanType);
break;
default:
break;
}
}
static void ble_start_connect(uint8_t *bleBdAddr) {
SET_BLE_OP(START_CONNECT);
if ((CONNECTING != bleModeEnv.state) &&
(STARTING_CONNECT != bleModeEnv.state)) {
switch (bleModeEnv.state) {
case ADVERTISING:
SET_BLE_STATE(STOPPING_ADV);
appm_stop_advertising();
break;
case SCANNING:
SET_BLE_STATE(STOPPING_SCAN);
appm_stop_scanning();
break;
case STATE_IDLE:
SET_BLE_STATE(STARTING_CONNECT);
struct gap_bdaddr bdAddr;
memcpy(bdAddr.addr.addr, bleBdAddr, BTIF_BD_ADDR_SIZE);
bdAddr.addr_type = 0;
LOG_I("Master paired with mobile dev is scanned, connect it via BLE.");
appm_start_connecting(&bdAddr);
break;
default:
break;
}
}
}
static void ble_stop_all_activities(void) {
switch (bleModeEnv.state) {
case ADVERTISING:
SET_BLE_OP(OP_IDLE);
SET_BLE_STATE(STOPPING_ADV);
appm_stop_advertising();
break;
case SCANNING:
SET_BLE_OP(OP_IDLE);
SET_BLE_STATE(STOPPING_SCAN);
appm_stop_scanning();
break;
case CONNECTING:
SET_BLE_OP(OP_IDLE);
SET_BLE_STATE(STOPPING_CONNECT);
appm_stop_connecting();
break;
case STARTING_ADV:
SET_BLE_OP(STOP_ADV);
break;
case STARTING_SCAN:
SET_BLE_OP(STOP_SCAN);
break;
case STARTING_CONNECT:
SET_BLE_OP(STOP_CONNECT);
break;
case STOPPING_ADV:
case STOPPING_SCAN:
case STOPPING_CONNECT:
SET_BLE_OP(OP_IDLE);
break;
default:
break;
}
}
static void ble_execute_pending_op(void) {
LOG_I("%s", __func__);
uint8_t op = bleModeEnv.op;
SET_BLE_OP(OP_IDLE);
switch (op) {
case START_ADV:
ble_start_adv(&advParam);
break;
case START_SCAN:
ble_start_scan(&scanParam);
break;
case START_CONNECT:
ble_start_connect(bleModeEnv.bleAddrToConnect);
break;
case STOP_ADV:
case STOP_SCAN:
case STOP_CONNECT:
ble_stop_all_activities();
break;
default:
break;
}
}
static void ble_switch_activities(void) {
switch (bleModeEnv.state) {
case STARTING_ADV:
SET_BLE_STATE(ADVERTISING);
break;
case STARTING_SCAN:
SET_BLE_STATE(SCANNING);
break;
case STARTING_CONNECT:
SET_BLE_STATE(CONNECTING);
break;
case STOPPING_ADV:
SET_BLE_STATE(STATE_IDLE);
break;
case STOPPING_SCAN:
SET_BLE_STATE(STATE_IDLE);
break;
case STOPPING_CONNECT:
SET_BLE_STATE(STATE_IDLE);
break;
default:
break;
}
ble_execute_pending_op();
}
// BLE advertisement event callbacks
void app_advertising_started(void) {
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
void app_advertising_starting_failed(void) {
memset(&bleModeEnv.advInfo, 0, sizeof(bleModeEnv.advInfo));
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_start_adv_failed_cb);
}
void app_advertising_stopped(void) {
memset(&bleModeEnv.advInfo, 0, sizeof(bleModeEnv.advInfo));
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
// BLE adv data updated event callback
void app_adv_data_updated(void) {
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
// BLE scan event callbacks
void app_scanning_started(void) {
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
void app_scanning_stopped(void) {
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
// BLE connect event callbacks
void app_connecting_started(void) {
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
void app_connecting_stopped(void) {
app_bt_start_custom_function_in_bt_thread(0, 0,
(uint32_t)ble_switch_activities);
}
/**
* @brief : callback function of BLE connect failed
*
*/
static void app_ble_connecting_failed_handler(void) {
if ((CONNECTING == bleModeEnv.state) ||
(STOPPING_CONNECT == bleModeEnv.state) ||
(STARTING_CONNECT == bleModeEnv.state)) {
SET_BLE_STATE(STATE_IDLE);
}
}
void app_connecting_failed(void) {
app_bt_start_custom_function_in_bt_thread(
0, 0, (uint32_t)app_ble_connecting_failed_handler);
}
void app_ble_connected_evt_handler(uint8_t conidx,
const uint8_t *pPeerBdAddress) {
ble_evnet_t event;
if ((ADVERTISING == bleModeEnv.state) || (STARTING_ADV == bleModeEnv.state) ||
(CONNECTING == bleModeEnv.state)) {
SET_BLE_STATE(STATE_IDLE);
}
if (START_CONNECT == bleModeEnv.op) {
SET_BLE_OP(OP_IDLE);
}
event.evt_type = BLE_CONNECT_EVENT;
event.p.connect_handled.conidx = conidx;
event.p.connect_handled.peer_bdaddr = pPeerBdAddress;
app_ble_core_global_handle(&event, NULL);
app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
app_stop_fast_connectable_ble_adv_timer();
}
void app_ble_disconnected_evt_handler(uint8_t conidx) {
ble_evnet_t event;
event.evt_type = BLE_DISCONNECT_EVENT;
event.p.disconnect_handled.conidx = conidx;
app_ble_core_global_handle(&event, NULL);
app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
}
// BLE APIs for external use
void app_ble_data_fill_enable(enum BLE_ADV_USER_E user, bool enable) {
LOG_I("%s user %d%s enable %d", __func__, user, ble_adv_user2str(user),
enable);
ASSERT(user < BLE_ADV_USER_NUM, "%s user %d", __func__, user);
if (enable) {
bleModeEnv.adv_user_enable |= (1 << user);
} else {
bleModeEnv.adv_user_enable &= ~(1 << user);
}
}
bool app_ble_get_data_fill_enable(enum BLE_ADV_USER_E user) {
bool enable = bleModeEnv.adv_user_enable & (1 << user);
LOG_I("%s user %d enable %d", __func__, user, enable);
return enable;
}
/**
* @brief : callback function of BLE scan starting failed
*
*/
static void app_ble_scanning_starting_failed_handler(void) {
if (STARTING_SCAN == bleModeEnv.state) {
SET_BLE_STATE(STATE_IDLE);
}
}
void app_scanning_starting_failed(void) {
app_bt_start_custom_function_in_bt_thread(
0, 0, (uint32_t)app_ble_scanning_starting_failed_handler);
}
// BLE APIs for external use
void app_ble_register_data_fill_handle(enum BLE_ADV_USER_E user,
BLE_DATA_FILL_FUNC_T func, bool enable) {
bool needUpdateAdv = false;
if (BLE_ADV_USER_NUM <= user) {
LOG_W("invalid user");
} else {
if (func != bleModeEnv.bleDataFillFunc[user] && NULL != func) {
needUpdateAdv = true;
bleModeEnv.bleDataFillFunc[user] = func;
}
}
bleModeEnv.adv_user_register |= (1 << user);
if (needUpdateAdv) {
app_ble_data_fill_enable(user, enable);
}
}
void app_ble_system_ready(void) {
uint32_t generatedSeed = hal_sys_timer_get();
for (uint8_t index = 0; index < sizeof(bt_addr); index++) {
generatedSeed ^=
(((uint32_t)(bt_addr[index])) << (hal_sys_timer_get() & 0xF));
}
bt_drv_reg_op_set_rand_seed(generatedSeed);
#if defined(ENHANCED_STACK)
app_notify_stack_ready(STACK_READY_BLE);
#else
app_notify_stack_ready(STACK_READY_BLE | STACK_READY_BT);
#endif
}
static void ble_adv_refreshing(void *param) {
BLE_ADV_PARAM_T *pAdvParam = (BLE_ADV_PARAM_T *)param;
// four conditions that we just need to update the ble adv data instead of
// restarting ble adv
// 1. BLE advertising is on
// 2. No on-going BLE operation
// 3. BLE adv type is the same
// 4. BLE adv interval is the same
if ((ADVERTISING == bleModeEnv.state) && (OP_IDLE == bleModeEnv.op) &&
bleModeEnv.advInfo.advType == pAdvParam->advType &&
bleModeEnv.advInfo.advInterval == pAdvParam->advInterval) {
memcpy(&bleModeEnv.advInfo, param, sizeof(bleModeEnv.advInfo));
SET_BLE_STATE(STARTING_ADV);
appm_update_adv_data(pAdvParam->advData, pAdvParam->advDataLen,
pAdvParam->scanRspData, pAdvParam->scanRspDataLen);
} else {
// otherwise, restart ble adv
ble_start_adv(param);
}
}
static bool app_ble_start_adv(uint8_t advType, uint16_t advInterval) {
uint32_t adv_user_enable = bleModeEnv.adv_user_enable;
LOG_I("[ADV]type:%d, interval:%d ca:%p", advType, advInterval,
__builtin_return_address(0));
if (!ble_adv_is_allowed()) {
LOG_I("[ADV] not allowed.");
return false;
}
ble_adv_config_param(advType, advInterval);
LOG_I("%s old_user_enable 0x%x new 0x%x", __func__, adv_user_enable,
bleModeEnv.adv_user_enable);
if (!bleModeEnv.adv_user_enable) {
LOG_I("no adv user enable");
LOG_I("[ADV] not allowed.");
app_ble_stop_activities();
return false;
}
// param of adv request is exactly same as current adv
if (ADVERTISING == bleModeEnv.state &&
!memcmp(&bleModeEnv.advInfo, &advParam, sizeof(advParam))) {
LOG_I("reason: adv param not changed");
LOG_I("[ADV] not allowed.");
return false;
}
LOG_I("[ADV_LEN] %d [DATA]:", advParam.advDataLen);
DUMP8("%02x ", advParam.advData, advParam.advDataLen);
LOG_I("[SCAN_RSP_LEN] %d [DATA]:", advParam.scanRspDataLen);
DUMP8("%02x ", advParam.scanRspData, advParam.scanRspDataLen);
ble_adv_refreshing(&advParam);
return true;
}
void app_ble_start_connectable_adv(uint16_t advInterval) {
LOG_D("%s", __func__);
app_bt_start_custom_function_in_bt_thread((uint32_t)GAPM_ADV_UNDIRECT,
(uint32_t)advInterval,
(uint32_t)app_ble_start_adv);
}
void app_ble_refresh_adv_state(uint16_t advInterval) {
LOG_D("%s", __func__);
app_bt_start_custom_function_in_bt_thread((uint32_t)GAPM_ADV_UNDIRECT,
(uint32_t)advInterval,
(uint32_t)app_ble_start_adv);
}
void app_ble_start_scan(enum BLE_SCAN_FILTER_POLICY scanFilterPolicy,
uint16_t scanWindow, uint16_t scanInterval) {
scanParam.scanWindow = scanWindow;
scanParam.scanInterval = scanInterval;
scanParam.scanType = scanFilterPolicy; // BLE_SCAN_ALLOW_ADV_WLST
app_bt_start_custom_function_in_bt_thread((uint32_t)(&scanParam), 0,
(uint32_t)ble_start_scan);
}
void app_ble_start_connect(uint8_t *bdAddrToConnect) {
memcpy(bleModeEnv.bleAddrToConnect, bdAddrToConnect, BTIF_BD_ADDR_SIZE);
app_bt_start_custom_function_in_bt_thread(
(uint32_t)bleModeEnv.bleAddrToConnect, 0, (uint32_t)ble_start_connect);
}
bool app_ble_is_connection_on(uint8_t index) {
return (BLE_CONNECTED == bleModeEnv.bleEnv->context[index].connectStatus);
}
bool app_ble_is_any_connection_exist(void) {
bool ret = false;
for (uint8_t i = 0; i < BLE_CONNECTION_MAX; i++) {
if (app_ble_is_connection_on(i)) {
ret = true;
}
}
return ret;
}
void app_ble_start_disconnect(uint8_t conIdx) {
if (BLE_CONNECTED == bleModeEnv.bleEnv->context[conIdx].connectStatus) {
LOG_I("will disconnect connection:%d", conIdx);
bleModeEnv.bleEnv->context[conIdx].connectStatus = BLE_DISCONNECTING;
app_bt_start_custom_function_in_bt_thread((uint32_t)conIdx, 0,
(uint32_t)appm_disconnect);
} else {
LOG_I("will not execute disconnect since state is:%d",
bleModeEnv.bleEnv->context[conIdx].connectStatus);
}
}
void app_ble_disconnect_all(void) {
for (uint8_t i = 0; i < BLE_CONNECTION_MAX; i++) {
app_ble_start_disconnect(i);
}
}
void app_ble_stop_activities(void) {
LOG_I("%s %p", __func__, __builtin_return_address(0));
app_stop_fast_connectable_ble_adv_timer();
if (bleModeEnv.state != OP_IDLE) {
app_bt_start_custom_function_in_bt_thread(
0, 0, (uint32_t)ble_stop_all_activities);
}
}
void app_ble_force_switch_adv(uint8_t user, bool onOff) {
ASSERT(user < BLE_SWITCH_USER_NUM, "ble switch user exceed");
if (onOff) {
bleModeEnv.advSwitch &= ~(1 << user);
app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
} else if ((bleModeEnv.advSwitch & (1 << user)) == 0) {
bleModeEnv.advSwitch |= (1 << user);
app_ble_stop_activities();
// disconnect all of the BLE connections if box is closed
if (BLE_SWITCH_USER_BOX == user) {
app_ble_disconnect_all();
}
}
LOG_I("%s user %d onoff %d switch 0x%x", __func__, user, onOff,
bleModeEnv.advSwitch);
}
bool app_ble_is_in_advertising_state(void) {
return (ADVERTISING == bleModeEnv.state) ||
(STARTING_ADV == bleModeEnv.state) ||
(STOPPING_ADV == bleModeEnv.state);
}
static uint32_t POSSIBLY_UNUSED ble_get_manufacture_data_ptr(
uint8_t *advData, uint32_t dataLength, uint8_t *manufactureData) {
uint8_t followingDataLengthOfSection;
uint8_t rawContentDataLengthOfSection;
uint8_t flag;
while (dataLength > 0) {
followingDataLengthOfSection = *advData++;
dataLength--;
if (dataLength < followingDataLengthOfSection) {
return 0; // wrong adv data format
}
if (followingDataLengthOfSection > 0) {
flag = *advData++;
dataLength--;
rawContentDataLengthOfSection = followingDataLengthOfSection - 1;
if (BLE_ADV_MANU_FLAG == flag) {
uint32_t lengthToCopy;
if (dataLength < rawContentDataLengthOfSection) {
lengthToCopy = dataLength;
} else {
lengthToCopy = rawContentDataLengthOfSection;
}
memcpy(manufactureData, advData - 2, lengthToCopy + 2);
return lengthToCopy + 2;
} else {
advData += rawContentDataLengthOfSection;
dataLength -= rawContentDataLengthOfSection;
}
}
}
return 0;
}
// received adv data
void app_adv_reported_scanned(struct gapm_adv_report_ind *ptInd) {
/*
LOG_I("Scanned RSSI %d BD addr:", (int8_t)ptInd->report.rssi);
DUMP8("0x%02x ", ptInd->report.adv_addr.addr, BTIF_BD_ADDR_SIZE);
LOG_I("Scanned adv data:");
DUMP8("0x%02x ", ptInd->report.data, ptInd->report.data_len);
*/
ble_adv_data_parse(ptInd->report.adv_addr.addr, (int8_t)ptInd->report.rssi,
ptInd->report.data, (unsigned char)ptInd->report.data_len);
}
void app_ibrt_ui_disconnect_ble(void) { app_ble_disconnect_all(); }
uint32_t app_ble_get_user_register(void) {
return bleModeEnv.adv_user_register;
}
enum BLE_STATE_E app_ble_get_current_state(void) { return bleModeEnv.state; }
enum BLE_OP_E app_ble_get_current_operation(void) { return bleModeEnv.op; }
void app_ble_get_runtime_adv_param(uint8_t *pAdvType,
uint16_t *pAdvIntervalMs) {
*pAdvType = advParam.advType;
*pAdvIntervalMs = advParam.advInterval;
}
Reference in a new issue View git blame Copy permalink