1235 lines
40 KiB
C
1235 lines
40 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.
|
|
*
|
|
****************************************************************************/
|
|
/**
|
|
****************************************************************************************
|
|
* @addtogroup APPTASK
|
|
* @{
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
****************************************************************************************
|
|
*/
|
|
|
|
#include "rwip_config.h" // SW configuration
|
|
|
|
#if (BLE_APP_PRESENT)
|
|
|
|
#include "app_task.h" // Application Manager Task API
|
|
#include "app.h" // Application Manager Definition
|
|
#include "gapc_task.h" // GAP Controller Task API
|
|
#include "gapm_task.h" // GAP Manager Task API
|
|
#include "arch.h" // Platform Definitions
|
|
#include <string.h>
|
|
#include "ke_timer.h" // Kernel timer
|
|
#include "gattc_task.h"
|
|
#include "app_ble_include.h"
|
|
#include "../l2cm/l2cm_int.h"
|
|
|
|
#include "co_utils.h"
|
|
#if (BLE_APP_SEC)
|
|
#include "app_sec.h" // Security Module Definition
|
|
#endif //(BLE_APP_SEC)
|
|
|
|
#if (BLE_APP_HT)
|
|
#include "app_ht.h" // Health Thermometer Module Definition
|
|
#include "htpt_task.h"
|
|
#endif //(BLE_APP_HT)
|
|
|
|
#if (BLE_APP_DIS)
|
|
#include "app_dis.h" // Device Information Module Definition
|
|
#include "diss_task.h"
|
|
#endif //(BLE_APP_DIS)
|
|
|
|
#if (BLE_APP_BATT)
|
|
#include "app_batt.h" // Battery Module Definition
|
|
#include "bass_task.h"
|
|
#endif //(BLE_APP_BATT)
|
|
|
|
#if (BLE_APP_HID)
|
|
#include "app_hid.h" // HID Module Definition
|
|
#include "hogpd_task.h"
|
|
#endif //(BLE_APP_HID)
|
|
|
|
#if (BLE_APP_HR)
|
|
#include "app_hrps.h"
|
|
#endif
|
|
|
|
#if (BLE_APP_VOICEPATH)
|
|
#include "app_voicepath_ble.h" // Voice Path Module Definition
|
|
#endif // (BLE_APP_VOICEPATH)
|
|
|
|
#if (BLE_APP_DATAPATH_SERVER)
|
|
#include "app_datapath_server.h" // Data Path Server Module Definition
|
|
#include "datapathps_task.h"
|
|
#endif // (BLE_APP_DATAPATH_SERVER)
|
|
|
|
#if (BLE_APP_AI_VOICE)
|
|
#include "app_ai_ble.h" // ama Voice Module Definition
|
|
#endif // (BLE_APP_AI_VOICE)
|
|
|
|
#if (BLE_APP_OTA)
|
|
#include "app_ota.h" // OTA Module Definition
|
|
#include "ota_task.h"
|
|
#endif // (BLE_APP_OTA)
|
|
|
|
#if (BLE_APP_TOTA)
|
|
#include "app_tota_ble.h" // TOTA Module Definition
|
|
#include "tota_task.h"
|
|
#endif // (BLE_APP_TOTA)
|
|
|
|
#if (BLE_APP_ANCC)
|
|
#include "app_ancc.h" // ANC Module Definition
|
|
#include "app_ancc_task.h"
|
|
#include "ancc_task.h"
|
|
#endif // (BLE_APP_ANCC)
|
|
|
|
#if (BLE_APP_AMS)
|
|
#include "app_amsc.h" // AMS Module Definition
|
|
#include "app_amsc_task.h"
|
|
#include "amsc_task.h"
|
|
#endif // (BLE_APP_AMS)
|
|
#if (BLE_APP_GFPS)
|
|
#include "app_gfps.h" // google fast pair service provider
|
|
#include "gfps_provider_task.h"
|
|
#endif // (BLE_APP_GFPS)
|
|
#ifdef BLE_APP_AM0
|
|
#include "am0_app.h" // Audio Mode 0 Application
|
|
#endif //defined(BLE_APP_AM0)
|
|
|
|
#if (DISPLAY_SUPPORT)
|
|
#include "app_display.h" // Application Display Definition
|
|
#endif //(DISPLAY_SUPPORT)
|
|
|
|
#include "bt_drv_interface.h"
|
|
#include "ble_app_dbg.h"
|
|
#include "nvrecord_ble.h"
|
|
#include "app_fp_rfcomm.h"
|
|
|
|
#if (BLE_APP_TILE)
|
|
#include "tile_target_ble.h"
|
|
#include "tile_gatt_server.h"
|
|
#endif
|
|
|
|
/*
|
|
* LOCAL FUNCTION DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
#define APP_CONN_PARAM_INTERVEL_MIN (20)
|
|
|
|
uint8_t ble_stack_ready = 0;
|
|
|
|
extern bool app_factorymode_get(void);
|
|
|
|
static uint8_t appm_get_handler(const struct ke_state_handler *handler_list,
|
|
ke_msg_id_t msgid,
|
|
void *param,
|
|
ke_task_id_t src_id)
|
|
{
|
|
// Counter
|
|
uint8_t counter;
|
|
|
|
// Get the message handler function by parsing the message table
|
|
for (counter = handler_list->msg_cnt; 0 < counter; counter--)
|
|
{
|
|
struct ke_msg_handler handler = (struct ke_msg_handler)(*(handler_list->msg_table + counter - 1));
|
|
|
|
if ((handler.id == msgid) ||
|
|
(handler.id == KE_MSG_DEFAULT_HANDLER))
|
|
{
|
|
// If handler is NULL, message should not have been received in this state
|
|
ASSERT_ERR(handler.func);
|
|
|
|
return (uint8_t)(handler.func(msgid, param, TASK_APP, src_id));
|
|
}
|
|
}
|
|
|
|
// If we are here no handler has been found, drop the message
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/*
|
|
* MESSAGE HANDLERS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int app_adv_timeout_handler(ke_msg_id_t const msgid,
|
|
void const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
#if (BLE_APP_HID)
|
|
#else
|
|
// Stop advertising
|
|
appm_stop_advertising();
|
|
#endif
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles ready indication from the GAP. - Reset the stack
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int gapm_device_ready_ind_handler(ke_msg_id_t const msgid,
|
|
void const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
if (ble_stack_ready)
|
|
{
|
|
return KE_MSG_CONSUMED;
|
|
}
|
|
|
|
#ifdef __FACTORY_MODE_SUPPORT__
|
|
if (app_factorymode_get())
|
|
{
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
#endif
|
|
|
|
BLE_APP_FUNC_ENTER();
|
|
|
|
// Application has not been initialized
|
|
ASSERT_ERR(ke_state_get(dest_id) == APPM_INIT);
|
|
|
|
ble_stack_ready = 1;
|
|
|
|
// Reset the stack
|
|
struct gapm_reset_cmd* cmd = KE_MSG_ALLOC(GAPM_RESET_CMD,
|
|
TASK_GAPM, TASK_APP,
|
|
gapm_reset_cmd);
|
|
|
|
cmd->operation = GAPM_RESET;
|
|
|
|
ke_msg_send(cmd);
|
|
|
|
BLE_APP_FUNC_LEAVE();
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles GAP manager command complete events.
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int gapm_cmp_evt_handler(ke_msg_id_t const msgid,
|
|
struct gapm_cmp_evt const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
BLE_APP_FUNC_ENTER();
|
|
BLE_APP_DBG("param->operation: %d status is %d app_env.next_svc is %d",
|
|
param->operation, param->status, app_env.next_svc);
|
|
|
|
switch(param->operation)
|
|
{
|
|
// Reset completed
|
|
case (GAPM_RESET):
|
|
{
|
|
if(param->status == GAP_ERR_NO_ERROR)
|
|
{
|
|
#if (BLE_APP_HID)
|
|
app_hid_start_mouse();
|
|
#endif //(BLE_APP_HID)
|
|
|
|
// Set Device configuration
|
|
struct gapm_set_dev_config_cmd* cmd = KE_MSG_ALLOC(GAPM_SET_DEV_CONFIG_CMD,
|
|
TASK_GAPM, TASK_APP,
|
|
gapm_set_dev_config_cmd);
|
|
// Set the operation
|
|
cmd->operation = GAPM_SET_DEV_CONFIG;
|
|
// Set the device role - Peripheral
|
|
cmd->role = GAP_ROLE_ALL;
|
|
// Set Data length parameters
|
|
cmd->sugg_max_tx_octets = APP_MAX_TX_OCTETS;
|
|
cmd->sugg_max_tx_time = APP_MAX_TX_TIME;
|
|
cmd->pairing_mode = GAPM_PAIRING_LEGACY;
|
|
#ifdef CFG_SEC_CON
|
|
cmd->pairing_mode |= GAPM_PAIRING_SEC_CON;
|
|
#endif
|
|
cmd->max_mtu = 512;
|
|
cmd->att_cfg = 0;
|
|
cmd->att_cfg |= GAPM_MASK_ATT_SVC_CHG_EN;
|
|
#if (BLE_APP_HID)
|
|
// Enable Slave Preferred Connection Parameters present
|
|
cmd->att_cfg |= GAPM_MASK_ATT_SLV_PREF_CON_PAR_EN;
|
|
#endif //(BLE_APP_HID)
|
|
|
|
#ifdef BLE_APP_AM0
|
|
cmd->addr_type = GAPM_CFG_ADDR_HOST_PRIVACY;
|
|
cmd->audio_cfg = GAPM_MASK_AUDIO_AM0_SUP;
|
|
#endif // BLE_APP_AM0
|
|
|
|
// load IRK
|
|
memcpy(cmd->irk.key, app_env.loc_irk, KEY_LEN);
|
|
|
|
// Send message
|
|
ke_msg_send(cmd);
|
|
}
|
|
else
|
|
{
|
|
ASSERT_ERR(0);
|
|
}
|
|
}
|
|
break;
|
|
case (GAPM_PROFILE_TASK_ADD):
|
|
{
|
|
// ASSERT_INFO(param->status == GAP_ERR_NO_ERROR, param->operation, param->status);
|
|
// Add the next requested service
|
|
if (!appm_add_svc())
|
|
{
|
|
// Go to the ready state
|
|
ke_state_set(TASK_APP, APPM_READY);
|
|
|
|
// No more service to add
|
|
app_ble_system_ready();
|
|
}
|
|
}
|
|
break;
|
|
// Device Configuration updated
|
|
case (GAPM_SET_DEV_CONFIG):
|
|
{
|
|
ASSERT_INFO(param->status == GAP_ERR_NO_ERROR, param->operation, param->status);
|
|
|
|
// Go to the create db state
|
|
ke_state_set(TASK_APP, APPM_CREATE_DB);
|
|
|
|
// Add the first required service in the database
|
|
// and wait for the PROFILE_ADDED_IND
|
|
appm_add_svc();
|
|
}
|
|
break;
|
|
|
|
case (GAPM_ADV_NON_CONN):
|
|
case (GAPM_ADV_UNDIRECT):
|
|
#if !(BLE_APP_HID)
|
|
case (GAPM_ADV_DIRECT):
|
|
#endif// !(BLE_APP_HID)
|
|
case (GAPM_ADV_DIRECT_LDC):
|
|
{
|
|
LOG_I("adv evt cmp status 0x%x", param->status);
|
|
ASSERT(GAP_ERR_ADV_DATA_INVALID != param->status,
|
|
"The BLE adv data or scan rsp data is invalid! Better check their length.");
|
|
|
|
if (GAP_ERR_CANCELED == param->status)
|
|
{
|
|
app_advertising_stopped();
|
|
}
|
|
else if (GAP_ERR_NO_ERROR == param->status)
|
|
{
|
|
if (ke_state_get(TASK_APP) == APPM_ADVERTISING)
|
|
{
|
|
app_advertising_started();
|
|
}
|
|
else
|
|
{
|
|
app_advertising_stopped();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
app_advertising_starting_failed();
|
|
}
|
|
|
|
break;
|
|
}
|
|
case GAPM_UPDATE_ADVERTISE_DATA:
|
|
{
|
|
app_adv_data_updated();
|
|
break;
|
|
}
|
|
case GAPM_SCAN_ACTIVE:
|
|
case GAPM_SCAN_PASSIVE:
|
|
{
|
|
LOG_I("scan evt cmp status %d", param->status);
|
|
if (GAP_ERR_CANCELED == param->status)
|
|
{
|
|
app_scanning_stopped();
|
|
}
|
|
else if (GAP_ERR_NO_ERROR == param->status)
|
|
{
|
|
app_scanning_started();
|
|
}
|
|
else
|
|
{
|
|
app_scanning_starting_failed();
|
|
}
|
|
}
|
|
break;
|
|
case GAPM_CONNECTION_DIRECT:
|
|
case GAPM_CONNECTION_AUTO:
|
|
case GAPM_CONNECTION_SELECTIVE:
|
|
case GAPM_CONNECTION_NAME_REQUEST:
|
|
case GAPM_CONNECTION_GENERAL:
|
|
{
|
|
BLE_GAP_DBG("connecting cmp status %d", param->status);
|
|
if (GAP_ERR_CANCELED == param->status)
|
|
{
|
|
app_connecting_stopped();
|
|
}
|
|
else if (GAP_ERR_NO_ERROR == param->status)
|
|
{
|
|
app_connecting_started();
|
|
}
|
|
else
|
|
{
|
|
app_connecting_failed();
|
|
}
|
|
}
|
|
break;
|
|
|
|
#if (BLE_APP_HID)
|
|
case (GAPM_ADV_DIRECT):
|
|
{
|
|
if (param->status == GAP_ERR_TIMEOUT)
|
|
{
|
|
ke_state_set(TASK_APP, APPM_READY);
|
|
}
|
|
} break;
|
|
#endif //(BLE_APP_HID)
|
|
case GAPM_RESOLV_ADDR:
|
|
{
|
|
LOG_I("Resolve result %d", param->status);
|
|
if (GAP_ERR_NOT_FOUND == param->status)
|
|
{
|
|
appm_random_ble_addr_solved(false, NULL);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// Drop the message
|
|
}
|
|
break;
|
|
}
|
|
|
|
BLE_APP_FUNC_LEAVE();
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
static int gapc_get_dev_info_req_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapc_get_dev_info_req_ind const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
switch(param->req)
|
|
{
|
|
case GAPC_DEV_NAME:
|
|
{
|
|
struct gapc_get_dev_info_cfm * cfm = KE_MSG_ALLOC_DYN(GAPC_GET_DEV_INFO_CFM,
|
|
src_id, dest_id,
|
|
gapc_get_dev_info_cfm, APP_DEVICE_NAME_MAX_LEN);
|
|
cfm->req = param->req;
|
|
cfm->info.name.length = appm_get_dev_name(cfm->info.name.value);
|
|
|
|
// Send message
|
|
ke_msg_send(cfm);
|
|
} break;
|
|
|
|
case GAPC_DEV_APPEARANCE:
|
|
{
|
|
// Allocate message
|
|
struct gapc_get_dev_info_cfm *cfm = KE_MSG_ALLOC(GAPC_GET_DEV_INFO_CFM,
|
|
src_id, dest_id,
|
|
gapc_get_dev_info_cfm);
|
|
cfm->req = param->req;
|
|
// Set the device appearance
|
|
#if (BLE_APP_HT)
|
|
// Generic Thermometer - TODO: Use a flag
|
|
cfm->info.appearance = 728;
|
|
#elif (BLE_APP_HID)
|
|
// HID Mouse
|
|
cfm->info.appearance = 962;
|
|
#else
|
|
// No appearance
|
|
cfm->info.appearance = 0;
|
|
#endif
|
|
|
|
// Send message
|
|
ke_msg_send(cfm);
|
|
} break;
|
|
|
|
case GAPC_DEV_SLV_PREF_PARAMS:
|
|
{
|
|
// Allocate message
|
|
struct gapc_get_dev_info_cfm *cfm = KE_MSG_ALLOC(GAPC_GET_DEV_INFO_CFM,
|
|
src_id, dest_id,
|
|
gapc_get_dev_info_cfm);
|
|
cfm->req = param->req;
|
|
// Slave preferred Connection interval Min
|
|
cfm->info.slv_params.con_intv_min = 8;
|
|
// Slave preferred Connection interval Max
|
|
cfm->info.slv_params.con_intv_max = 10;
|
|
// Slave preferred Connection latency
|
|
cfm->info.slv_params.slave_latency = 0;
|
|
// Slave preferred Link supervision timeout
|
|
cfm->info.slv_params.conn_timeout = 200; // 2s (500*10ms)
|
|
|
|
// Send message
|
|
ke_msg_send(cfm);
|
|
} break;
|
|
|
|
default: /* Do Nothing */ break;
|
|
}
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles GAPC_SET_DEV_INFO_REQ_IND message.
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int gapc_set_dev_info_req_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapc_set_dev_info_req_ind const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
// Set Device configuration
|
|
struct gapc_set_dev_info_cfm* cfm = KE_MSG_ALLOC(GAPC_SET_DEV_INFO_CFM, src_id, dest_id,
|
|
gapc_set_dev_info_cfm);
|
|
// Reject to change parameters
|
|
cfm->status = GAP_ERR_REJECTED;
|
|
cfm->req = param->req;
|
|
// Send message
|
|
ke_msg_send(cfm);
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
static void POSSIBLY_UNUSED gapc_refresh_remote_dev_feature(uint8_t conidx)
|
|
{
|
|
// Send a GAPC_GET_INFO_CMD in order to read the device name characteristic value
|
|
struct gapc_get_info_cmd *p_cmd = KE_MSG_ALLOC(GAPC_GET_INFO_CMD,
|
|
KE_BUILD_ID(TASK_GAPC, conidx), TASK_GAPM,
|
|
gapc_get_info_cmd);
|
|
|
|
// request peer device name.
|
|
p_cmd->operation = GAPC_GET_PEER_FEATURES;
|
|
|
|
// send command
|
|
ke_msg_send(p_cmd);
|
|
}
|
|
|
|
static void POSSIBLY_UNUSED gpac_exchange_data_packet_length(uint8_t conidx)
|
|
{
|
|
#if defined(CHIP_BEST2300) || defined(CHIP_BEST2300P)
|
|
return;
|
|
#endif
|
|
|
|
struct gapc_set_le_pkt_size_cmd *set_le_pakt_size_req = KE_MSG_ALLOC(GAPC_SET_LE_PKT_SIZE_CMD,
|
|
KE_BUILD_ID(TASK_GAPC, conidx),
|
|
TASK_APP,
|
|
gapc_set_le_pkt_size_cmd);
|
|
|
|
set_le_pakt_size_req->operation = GAPC_SET_LE_PKT_SIZE;
|
|
set_le_pakt_size_req->tx_octets = APP_MAX_TX_OCTETS;
|
|
set_le_pakt_size_req->tx_time = APP_MAX_TX_TIME;
|
|
// Send message
|
|
ke_msg_send(set_le_pakt_size_req);
|
|
}
|
|
|
|
static int gapc_peer_features_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapc_peer_features_ind* param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
LOG_I("Peer dev feature is:");
|
|
DUMP8("0x%02x ", param->features, GAP_LE_FEATS_LEN);
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
|
|
if (param->features[0] & GAPC_EXT_DATA_LEN_MASK)
|
|
{
|
|
gpac_exchange_data_packet_length(conidx);
|
|
}
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
void app_exchange_remote_feature(uint8_t conidx)
|
|
{
|
|
APP_BLE_CONN_CONTEXT_T *pContext = &(app_env.context[conidx]);
|
|
|
|
LOG_I("connectStatus:%d, isFeatureExchanged:%d, isGotSolvedBdAddr:%d",
|
|
pContext->connectStatus,
|
|
pContext->isFeatureExchanged,
|
|
pContext->isGotSolvedBdAddr);
|
|
|
|
if ((BLE_CONNECTED == pContext->connectStatus) && !pContext->isFeatureExchanged)
|
|
{
|
|
if (pContext->isGotSolvedBdAddr)
|
|
{
|
|
gapc_refresh_remote_dev_feature(conidx);
|
|
pContext->isFeatureExchanged = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles connection complete event from the GAP. Enable all required profiles
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int gapc_connection_req_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapc_connection_req_ind* param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
|
|
APP_BLE_CONN_CONTEXT_T* pContext = &(app_env.context[conidx]);
|
|
|
|
pContext->connectStatus = BLE_CONNECTED;
|
|
|
|
APP_BLE_NEGOTIATED_CONN_PARAM_T connParam;
|
|
connParam.con_interval = param->con_interval;
|
|
connParam.sup_to= param->sup_to;
|
|
connParam.con_latency = param->con_latency;
|
|
app_ble_save_negotiated_conn_param(conidx, &connParam);
|
|
|
|
ke_state_set(dest_id, APPM_CONNECTED);
|
|
|
|
app_env.conn_cnt++;
|
|
|
|
if (app_is_resolving_ble_bd_addr())
|
|
{
|
|
LOG_I("A ongoing ble addr solving is in progress, refuse the new connection.");
|
|
appm_disconnect(conidx);
|
|
return KE_MSG_CONSUMED;
|
|
}
|
|
|
|
LOG_I("[CONNECT]device info:");
|
|
LOG_I("peer addr:");
|
|
DUMP8("%02x ", param->peer_addr.addr, 6);
|
|
LOG_I("peer addr type:%d", param->peer_addr_type);
|
|
LOG_I("connection index:%d, isGotSolvedBdAddr:%d", conidx, pContext->isGotSolvedBdAddr);
|
|
LOG_I("conn interval:%d, timeout:%d", param->con_interval, param->sup_to);
|
|
|
|
BLE_APP_FUNC_ENTER();
|
|
|
|
// Check if the received Connection Handle was valid
|
|
if (conidx != GAP_INVALID_CONIDX)
|
|
{
|
|
pContext->peerAddrType = param->peer_addr_type;
|
|
memcpy(pContext->bdAddr, param->peer_addr.addr, BD_ADDR_LEN);
|
|
|
|
// Retrieve the connection info from the parameters
|
|
pContext->conhdl = param->conhdl;
|
|
|
|
if (BLE_RANDOM_ADDR == pContext->peerAddrType)
|
|
{
|
|
pContext->isGotSolvedBdAddr = false;
|
|
}
|
|
else
|
|
{
|
|
pContext->isGotSolvedBdAddr = true;
|
|
}
|
|
|
|
// Clear the advertising timeout timer
|
|
if (ke_timer_active(APP_ADV_TIMEOUT_TIMER, TASK_APP))
|
|
{
|
|
ke_timer_clear(APP_ADV_TIMEOUT_TIMER, TASK_APP);
|
|
}
|
|
|
|
#if (BLE_APP_SEC)
|
|
app_sec_reset_env_on_connection();
|
|
#endif
|
|
|
|
// Send connection confirmation
|
|
struct gapc_connection_cfm *cfm = KE_MSG_ALLOC(GAPC_CONNECTION_CFM,
|
|
KE_BUILD_ID(TASK_GAPC, conidx), TASK_APP,
|
|
gapc_connection_cfm);
|
|
|
|
#if (BLE_APP_SEC)
|
|
cfm->auth = app_sec_get_bond_status() ? BLE_AUTHENTICATION_LEVEL : GAP_AUTH_REQ_NO_MITM_NO_BOND;
|
|
#else // !(BLE_APP_SEC)
|
|
cfm->auth = GAP_AUTH_REQ_NO_MITM_NO_BOND;
|
|
#endif // (BLE_APP_SEC)
|
|
// Send the message
|
|
ke_msg_send(cfm);
|
|
|
|
// We are now in connected State
|
|
ke_state_set(dest_id, APPM_CONNECTED);
|
|
app_exchange_remote_feature(conidx);
|
|
|
|
app_ble_connected_evt_handler(conidx, param->peer_addr.addr);
|
|
}
|
|
|
|
#if (BLE_APP_TILE)
|
|
app_tile_connected_evt_handler(conidx, param);
|
|
#endif
|
|
|
|
app_env.context[conidx].connInterval = param->con_interval;
|
|
|
|
app_ble_update_conn_param_mode(BLE_CONN_PARAM_MODE_DEFAULT, true);
|
|
BLE_APP_FUNC_LEAVE();
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles GAP controller command complete events.
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int gapc_cmp_evt_handler(ke_msg_id_t const msgid,
|
|
struct gapc_cmp_evt const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
switch(param->operation)
|
|
{
|
|
case (GAPC_UPDATE_PARAMS):
|
|
{
|
|
if (param->status != GAP_ERR_NO_ERROR)
|
|
{
|
|
// appm_disconnect();
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
{
|
|
} break;
|
|
}
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles disconnection complete event from the GAP.
|
|
*
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int gapc_disconnect_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapc_disconnect_ind const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
LOG_I("[DISCONNECT] device info:");
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
LOG_I("connection index:%d, reason:0x%x", conidx, param->reason);
|
|
|
|
app_env.context[conidx].isBdAddrResolvingInProgress = false;
|
|
app_env.context[conidx].isGotSolvedBdAddr = false;
|
|
|
|
app_env.context[conidx].connectStatus = BLE_DISCONNECTED;
|
|
app_env.context[conidx].isFeatureExchanged = false;
|
|
app_env.context[conidx].connInterval = 0;
|
|
l2cm_buffer_reset(conidx);
|
|
|
|
// Go to the ready state
|
|
ke_state_set(TASK_APP, APPM_READY);
|
|
|
|
app_env.conn_cnt--;
|
|
|
|
#if (BLE_VOICEPATH)
|
|
app_voicepath_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
#if (BLE_DATAPATH_SERVER)
|
|
app_datapath_server_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
#if (BLE_OTA)
|
|
app_ota_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
#if (BLE_APP_TOTA)
|
|
app_tota_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
#if(BLE_APP_GFPS)
|
|
app_gfps_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
|
|
#if (BLE_AI_VOICE)
|
|
app_ai_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
#if (BLE_APP_TILE)
|
|
app_tile_disconnected_evt_handler(conidx);
|
|
#endif
|
|
|
|
app_ble_disconnected_evt_handler(conidx);
|
|
|
|
app_ble_reset_conn_param_mode(conidx);
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
|
|
static int gapm_profile_added_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapm_profile_added_ind *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
LOG_I("prf_task_id %d is added.", param->prf_task_id);
|
|
|
|
return KE_MSG_CONSUMED;
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles reception of all messages sent from the lower layers to the application
|
|
* @param[in] msgid Id of the message received.
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance
|
|
* @param[in] src_id ID of the sending task instance.
|
|
*
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
static int appm_msg_handler(ke_msg_id_t const msgid,
|
|
void *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
// Retrieve identifier of the task from received message
|
|
ke_task_id_t src_task_id = MSG_T(msgid);
|
|
// Message policy
|
|
uint8_t msg_pol = KE_MSG_CONSUMED;
|
|
|
|
|
|
switch (src_task_id)
|
|
{
|
|
case (TASK_ID_GAPC):
|
|
{
|
|
#if (BLE_APP_SEC)
|
|
if ((msgid >= GAPC_BOND_CMD) &&
|
|
(msgid <= GAPC_SECURITY_IND))
|
|
{
|
|
// Call the Security Module
|
|
msg_pol = appm_get_handler(&app_sec_table_handler, msgid, param, src_id);
|
|
}
|
|
#endif //(BLE_APP_SEC)
|
|
// else drop the message
|
|
} break;
|
|
|
|
case (TASK_ID_GATTC):
|
|
{
|
|
// Service Changed - Drop
|
|
} break;
|
|
|
|
#if (BLE_APP_HT)
|
|
case (TASK_ID_HTPT):
|
|
{
|
|
// Call the Health Thermometer Module
|
|
msg_pol = appm_get_handler(&app_ht_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_HT)
|
|
|
|
#if (BLE_APP_DIS)
|
|
case (TASK_ID_DISS):
|
|
{
|
|
// Call the Device Information Module
|
|
msg_pol = appm_get_handler(&app_dis_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_DIS)
|
|
|
|
#if (BLE_APP_HID)
|
|
case (TASK_ID_HOGPD):
|
|
{
|
|
// Call the HID Module
|
|
msg_pol = appm_get_handler(&app_hid_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_HID)
|
|
|
|
#if (BLE_APP_BATT)
|
|
case (TASK_ID_BASS):
|
|
{
|
|
// Call the Battery Module
|
|
msg_pol = appm_get_handler(&app_batt_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_BATT)
|
|
|
|
#if defined(BLE_APP_AM0)
|
|
case (TASK_ID_AM0):
|
|
{
|
|
// Call the Audio Mode 0 Module
|
|
msg_pol = appm_get_handler(&am0_app_table_handler, msgid, param, src_id);
|
|
} break;
|
|
case (TASK_ID_AM0_HAS):
|
|
{
|
|
// Call the Audio Mode 0 Module
|
|
msg_pol = appm_get_handler(&am0_app_has_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif // defined(BLE_APP_AM0)
|
|
|
|
#if (BLE_APP_HR)
|
|
case (TASK_ID_HRPS):
|
|
{
|
|
// Call the HRPS Module
|
|
msg_pol = appm_get_handler(&app_hrps_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif
|
|
|
|
#if (BLE_APP_VOICEPATH)
|
|
case (TASK_ID_VOICEPATH):
|
|
{
|
|
// Call the Voice Path Module
|
|
msg_pol = appm_get_handler(app_voicepath_ble_get_msg_handler_table(), msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_VOICEPATH)
|
|
|
|
#if (BLE_APP_DATAPATH_SERVER)
|
|
case (TASK_ID_DATAPATHPS):
|
|
{
|
|
// Call the Data Path Module
|
|
msg_pol = appm_get_handler(&app_datapath_server_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_DATAPATH_SERVER)
|
|
#if (BLE_APP_TILE)
|
|
case (TASK_ID_TILE):
|
|
{
|
|
// Call the TILE Module
|
|
msg_pol = appm_get_handler(&app_tile_table_handler, msgid, param, src_id);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#if (BLE_APP_AI_VOICE)
|
|
case (TASK_ID_AI):
|
|
{
|
|
// Call the AI Voice
|
|
msg_pol = appm_get_handler(app_ai_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_AI_VOICE)
|
|
|
|
#if (BLE_APP_OTA)
|
|
case (TASK_ID_OTA):
|
|
{
|
|
// Call the OTA
|
|
msg_pol = appm_get_handler(&app_ota_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_OTA)
|
|
|
|
#if (BLE_APP_TOTA)
|
|
case (TASK_ID_TOTA):
|
|
{
|
|
// Call the TOTA
|
|
msg_pol = appm_get_handler(&app_tota_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_TOTA)
|
|
|
|
#if (BLE_APP_ANCC)
|
|
case (TASK_ID_ANCC):
|
|
{
|
|
// Call the ANCC
|
|
msg_pol = appm_get_handler(&app_ancc_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_ANCC)
|
|
|
|
#if (BLE_APP_AMS)
|
|
case (TASK_ID_AMSC):
|
|
{
|
|
// Call the AMS
|
|
msg_pol = appm_get_handler(&app_amsc_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif //(BLE_APP_AMS)
|
|
#if (BLE_APP_GFPS)
|
|
case (TASK_ID_GFPSP):
|
|
{
|
|
msg_pol = appm_get_handler(&app_gfps_table_handler, msgid, param, src_id);
|
|
} break;
|
|
#endif
|
|
|
|
default:
|
|
{
|
|
#if (BLE_APP_HT)
|
|
if (msgid == APP_HT_MEAS_INTV_TIMER)
|
|
{
|
|
msg_pol = appm_get_handler(&app_ht_table_handler, msgid, param, src_id);
|
|
}
|
|
#endif //(BLE_APP_HT)
|
|
|
|
#if (BLE_APP_HID)
|
|
if (msgid == APP_HID_MOUSE_TIMEOUT_TIMER)
|
|
{
|
|
msg_pol = appm_get_handler(&app_hid_table_handler, msgid, param, src_id);
|
|
}
|
|
#endif //(BLE_APP_HID)
|
|
} break;
|
|
}
|
|
|
|
return (msg_pol);
|
|
}
|
|
|
|
static int gapm_adv_report_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapm_adv_report_ind *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
app_adv_reported_scanned(param);
|
|
return KE_MSG_CONSUMED;
|
|
}
|
|
|
|
static int gapm_addr_solved_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapm_addr_solved_ind *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
/// Indicate that resolvable random address has been solved
|
|
appm_random_ble_addr_solved(true, param->irk.key);
|
|
return KE_MSG_CONSUMED;
|
|
}
|
|
|
|
__STATIC int gattc_mtu_changed_ind_handler(ke_msg_id_t const msgid,
|
|
struct gattc_mtu_changed_ind const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
|
|
LOG_I("MTU has been negotiated as %d conidx %d", param->mtu, conidx);
|
|
|
|
|
|
#if (BLE_APP_DATAPATH_SERVER)
|
|
app_datapath_server_mtu_exchanged_handler(conidx, param->mtu);
|
|
#endif
|
|
|
|
#if (BLE_VOICEPATH)
|
|
app_voicepath_mtu_exchanged_handler(conidx, param->mtu);
|
|
#endif
|
|
|
|
#if (BLE_OTA)
|
|
app_ota_mtu_exchanged_handler(conidx, param->mtu);
|
|
#endif
|
|
|
|
#if (BLE_APP_TOTA)
|
|
app_tota_mtu_exchanged_handler(conidx, param->mtu);
|
|
#endif
|
|
|
|
#if (BLE_AI_VOICE)
|
|
app_ai_mtu_exchanged_handler(conidx, param->mtu);
|
|
#endif
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
#define APP_CONN_PARAM_INTERVEL_MAX (30)
|
|
__STATIC int gapc_conn_param_update_req_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapc_param_update_req_ind const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
bool accept = true;
|
|
ble_evnet_t event;
|
|
|
|
LOG_I("Receive the conn param update request: min %d max %d latency %d timeout %d",
|
|
param->intv_min,
|
|
param->intv_max,
|
|
param->latency,
|
|
param->time_out);
|
|
|
|
struct gapc_param_update_cfm* cfm = KE_MSG_ALLOC(GAPC_PARAM_UPDATE_CFM, src_id, dest_id,
|
|
gapc_param_update_cfm);
|
|
|
|
event.evt_type = BLE_CONN_PARAM_UPDATE_REQ_EVENT;
|
|
event.p.conn_param_update_req_handled.intv_min = param->intv_min;
|
|
event.p.conn_param_update_req_handled.intv_max = param->intv_max;
|
|
event.p.conn_param_update_req_handled.latency = param->latency;
|
|
event.p.conn_param_update_req_handled.time_out = param->time_out;
|
|
|
|
app_ble_core_global_handle(&event, &accept);
|
|
LOG_I("%s ret %d ", __func__, accept);
|
|
|
|
cfm->accept = accept;
|
|
|
|
#ifdef GFPS_ENABLED
|
|
// if fastpair doesn't have the requirement of finishing
|
|
// pairing in a really short period, just comment out this
|
|
// code block to avoid audio glitch if this event happens during music
|
|
// playback and interval is smaller than 15ms
|
|
if (param->intv_min < (uint16_t)(15/1.25))
|
|
{
|
|
LOG_I("accept");
|
|
cfm->accept = true;
|
|
fp_update_ble_connect_param_start(KE_IDX_GET(src_id));
|
|
}
|
|
else
|
|
{
|
|
fp_update_ble_connect_param_stop(KE_IDX_GET(src_id));
|
|
}
|
|
#endif
|
|
|
|
ke_msg_send(cfm);
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
static int gapc_conn_param_updated_handler(ke_msg_id_t const msgid,
|
|
struct gapc_param_updated_ind* param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
LOG_I("Conidx %d conn parameter is updated as interval %d timeout %d",
|
|
conidx,
|
|
param->con_interval,
|
|
param->sup_to);
|
|
|
|
APP_BLE_NEGOTIATED_CONN_PARAM_T connParam;
|
|
connParam.con_interval = param->con_interval;
|
|
connParam.sup_to= param->sup_to;
|
|
connParam.con_latency = param->con_latency;
|
|
app_ble_save_negotiated_conn_param(conidx, &connParam);
|
|
|
|
#if (BLE_VOICEPATH)
|
|
app_voicepath_ble_conn_parameter_updated(conidx, param->con_interval, param->con_latency);
|
|
#endif
|
|
#if BLE_APP_TILE
|
|
app_tile_ble_conn_parameter_updated(conidx, param);
|
|
#endif
|
|
|
|
app_env.context[conidx].connInterval = param->con_interval;
|
|
|
|
if (param->con_interval >= 32)
|
|
{
|
|
if (app_ble_is_parameter_mode_enabled(conidx, BLE_CONN_PARAM_MODE_OTA))
|
|
{
|
|
app_ble_parameter_mode_clear(conidx, BLE_CONN_PARAM_MODE_OTA);
|
|
app_ble_update_conn_param_mode(BLE_CONN_PARAM_MODE_OTA_SLOWER, true);
|
|
}
|
|
else if (app_ble_is_parameter_mode_enabled(conidx, BLE_CONN_PARAM_MODE_AI_STREAM_ON))
|
|
{
|
|
app_ble_parameter_mode_clear(conidx, BLE_CONN_PARAM_MODE_AI_STREAM_ON);
|
|
app_ble_update_conn_param_mode(BLE_CONN_PARAM_MODE_AI_STREAM_ON, true);
|
|
}
|
|
}
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
static int gapm_dev_addr_ind_handler(ke_msg_id_t const msgid,
|
|
struct gapm_dev_bdaddr_ind *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id)
|
|
{
|
|
ble_evnet_t event;
|
|
|
|
// Indicate that a new random BD address set in lower layers
|
|
LOG_I("New dev addr:");
|
|
DUMP8("%02x ", param->addr.addr.addr, 6);
|
|
|
|
#ifdef GFPS_ENABLED
|
|
app_fp_msg_send_updated_ble_addr();
|
|
app_gfps_update_random_salt();
|
|
#endif
|
|
|
|
|
|
event.evt_type = BLE_SET_RANDOM_BD_ADDR_EVENT;
|
|
event.p.set_random_bd_addr_handled.new_bdaddr = param->addr.addr.addr;
|
|
app_ble_core_global_handle(&event, NULL);
|
|
|
|
return KE_MSG_CONSUMED;
|
|
}
|
|
|
|
|
|
/*
|
|
* GLOBAL VARIABLES DEFINITION
|
|
****************************************************************************************
|
|
*/
|
|
/* Default State handlers definition. */
|
|
KE_MSG_HANDLER_TAB(appm)
|
|
{
|
|
// Note: first message is latest message checked by kernel so default is put on top.
|
|
{KE_MSG_DEFAULT_HANDLER, (ke_msg_func_t)appm_msg_handler},
|
|
|
|
{APP_ADV_TIMEOUT_TIMER, (ke_msg_func_t)app_adv_timeout_handler},
|
|
|
|
{GAPM_DEVICE_READY_IND, (ke_msg_func_t)gapm_device_ready_ind_handler},
|
|
{GAPM_CMP_EVT, (ke_msg_func_t)gapm_cmp_evt_handler},
|
|
{GAPC_GET_DEV_INFO_REQ_IND, (ke_msg_func_t)gapc_get_dev_info_req_ind_handler},
|
|
{GAPC_SET_DEV_INFO_REQ_IND, (ke_msg_func_t)gapc_set_dev_info_req_ind_handler},
|
|
{GAPC_CONNECTION_REQ_IND, (ke_msg_func_t)gapc_connection_req_ind_handler},
|
|
{GAPC_CMP_EVT, (ke_msg_func_t)gapc_cmp_evt_handler},
|
|
{GAPC_DISCONNECT_IND, (ke_msg_func_t)gapc_disconnect_ind_handler},
|
|
{GAPM_PROFILE_ADDED_IND, (ke_msg_func_t)gapm_profile_added_ind_handler},
|
|
{GATTC_MTU_CHANGED_IND, (ke_msg_func_t)gattc_mtu_changed_ind_handler},
|
|
{GAPC_PARAM_UPDATE_REQ_IND, (ke_msg_func_t)gapc_conn_param_update_req_ind_handler},
|
|
{GAPC_PARAM_UPDATED_IND, (ke_msg_func_t)gapc_conn_param_updated_handler},
|
|
{GAPM_ADV_REPORT_IND, (ke_msg_func_t)gapm_adv_report_ind_handler},
|
|
{GAPC_PEER_FEATURES_IND, (ke_msg_func_t)gapc_peer_features_ind_handler},
|
|
{GAPM_ADDR_SOLVED_IND, (ke_msg_func_t)gapm_addr_solved_ind_handler},
|
|
{GAPM_DEV_BDADDR_IND, (ke_msg_func_t)gapm_dev_addr_ind_handler},
|
|
};
|
|
|
|
|
|
/* Defines the place holder for the states of all the task instances. */
|
|
ke_state_t appm_state[APP_IDX_MAX];
|
|
|
|
const struct ke_task_desc TASK_DESC_APP = {appm_msg_handler_tab, appm_state, APP_IDX_MAX, ARRAY_LEN(appm_msg_handler_tab)};
|
|
|
|
#endif //(BLE_APP_PRESENT)
|
|
|
|
/// @} APPTASK
|