1211 lines
31 KiB
C
1211 lines
31 KiB
C
/***************************************************************************
|
|
*
|
|
*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 "string.h"
|
|
#include "co_math.h" // Common Maths Definition
|
|
#include "cmsis_os.h"
|
|
#include "ble_app_dbg.h"
|
|
#include "stdbool.h"
|
|
#include "app_thread.h"
|
|
#include "app_utils.h"
|
|
#include "apps.h"
|
|
#include "app.h"
|
|
#include "app_sec.h"
|
|
#include "app_ble_include.h"
|
|
#include "nvrecord.h"
|
|
#include "app_bt_func.h"
|
|
#include "hal_timer.h"
|
|
#include "app_bt.h"
|
|
#include "app_hfp.h"
|
|
#include "rwprf_config.h"
|
|
#include "nvrecord_ble.h"
|
|
#include "app_sec.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;
|
|
}
|
|
|