591 lines
22 KiB
C
591 lines
22 KiB
C
/**
|
|
****************************************************************************************
|
|
* @addtogroup ANPSTASK
|
|
* @{
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
****************************************************************************************
|
|
*/
|
|
|
|
#include "rwip_config.h"
|
|
|
|
#if (BLE_AN_SERVER)
|
|
|
|
#include "anps.h"
|
|
#include "anps_task.h"
|
|
#include "gapm.h"
|
|
#include "gattc_task.h"
|
|
|
|
#include "prf_types.h"
|
|
#include "prf_utils.h"
|
|
|
|
#include "co_utils.h"
|
|
|
|
/*
|
|
* LOCAL FUNCTIONS DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles reception of the @ref ANPS_ENABLE_REQ 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.
|
|
* @param[in] src_id ID of the sending task instance.
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
__STATIC int anps_enable_req_handler(ke_msg_id_t const msgid,
|
|
struct anps_enable_req *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id) {
|
|
// Alert Notification Profile Server Role Task Index Environment
|
|
struct anps_env_tag *anps_env = PRF_ENV_GET(ANPS, anps);
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
// Status
|
|
uint8_t status = PRF_ERR_REQ_DISALLOWED;
|
|
|
|
if (ke_state_get(dest_id) == ANPS_IDLE) {
|
|
if (anps_env->env[conidx] != NULL) {
|
|
// Bonded data was not used before
|
|
if (!ANPS_IS_ALERT_ENABLED(conidx, anps_env,
|
|
ANPS_FLAG_CFG_PERFORMED_OK)) {
|
|
status = GAP_ERR_NO_ERROR;
|
|
// Update the state in the environment
|
|
if (param->new_alert_ntf_cfg != PRF_CLI_STOP_NTFIND) {
|
|
// Force to PRF_CLI_START_NTF
|
|
param->new_alert_ntf_cfg = PRF_CLI_START_NTF;
|
|
|
|
ANPS_ENABLE_ALERT(conidx, anps_env, ANP_NEW_ALERT);
|
|
}
|
|
|
|
if (param->unread_alert_status_ntf_cfg != PRF_CLI_STOP_NTFIND) {
|
|
// Force to PRF_CLI_START_NTF
|
|
param->unread_alert_status_ntf_cfg = PRF_CLI_START_NTF;
|
|
|
|
ANPS_ENABLE_ALERT(conidx, anps_env, ANP_UNREAD_ALERT);
|
|
}
|
|
}
|
|
// Enable Bonded Data
|
|
ANPS_ENABLE_ALERT(conidx, anps_env, ANPS_FLAG_CFG_PERFORMED_OK);
|
|
}
|
|
}
|
|
|
|
// send completed information to APP task that contains error status
|
|
struct anps_enable_rsp *cmp_evt =
|
|
KE_MSG_ALLOC(ANPS_ENABLE_RSP, src_id, dest_id, anps_enable_rsp);
|
|
cmp_evt->status = status;
|
|
ke_msg_send(cmp_evt);
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles reception of the @ref ANPS_NTF_ALERT_CMD 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.
|
|
* @param[in] src_id ID of the sending task instance.
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
__STATIC int anps_ntf_alert_cmd_handler(ke_msg_id_t const msgid,
|
|
struct anps_ntf_alert_cmd const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id) {
|
|
// Status
|
|
uint8_t status = PRF_ERR_INVALID_PARAM;
|
|
// Message Status
|
|
uint8_t msg_status = KE_MSG_CONSUMED;
|
|
// Task environment
|
|
struct anps_env_tag *anps_env = PRF_ENV_GET(ANPS, anps);
|
|
uint8_t conidx = KE_IDX_GET(dest_id);
|
|
uint8_t state = ke_state_get(dest_id);
|
|
|
|
if (state == ANPS_IDLE) {
|
|
// Category ID
|
|
uint8_t cat_id;
|
|
// Is the category supported ?
|
|
bool cat_supported;
|
|
// Handle
|
|
uint16_t handle = ATT_ERR_INVALID_HANDLE;
|
|
|
|
ASSERT_ERR(anps_env != NULL);
|
|
ASSERT_ERR(anps_env->env[conidx] != NULL);
|
|
|
|
do {
|
|
// Check the operation code, get the category ID.
|
|
if (param->operation == ANPS_UPD_NEW_ALERT_OP_CODE) {
|
|
// Check the length of the string info value
|
|
if (param->value.new_alert.info_str_len >
|
|
ANS_NEW_ALERT_STRING_INFO_MAX_LEN) {
|
|
status = PRF_ERR_INVALID_PARAM;
|
|
break;
|
|
}
|
|
|
|
// Get the category ID
|
|
cat_id = param->value.new_alert.cat_id;
|
|
// Check if the category is supported
|
|
cat_supported = ANPS_IS_NEW_ALERT_CATEGORY_SUPPORTED(cat_id);
|
|
} else if (param->operation == ANPS_UPD_UNREAD_ALERT_STATUS_OP_CODE) {
|
|
// Get the category ID
|
|
cat_id = param->value.unread_alert_status.cat_id;
|
|
// Check if the category is supported
|
|
cat_supported = ANPS_IS_UNREAD_ALERT_CATEGORY_SUPPORTED(cat_id);
|
|
} else {
|
|
status = PRF_ERR_INVALID_PARAM;
|
|
break;
|
|
}
|
|
|
|
// Check the category ID
|
|
if ((cat_id >= CAT_ID_NB) || (!cat_supported)) {
|
|
status = PRF_ERR_INVALID_PARAM;
|
|
break;
|
|
}
|
|
|
|
if (param->operation == ANPS_UPD_NEW_ALERT_OP_CODE) {
|
|
// Check if sending of notification is enabled for the provided category
|
|
if (ANPS_IS_NEW_ALERT_CATEGORY_ENABLED(conidx, cat_id, anps_env) &&
|
|
ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_NEW_ALERT)) {
|
|
handle = anps_env->shdl + ANS_IDX_NEW_ALERT_VAL;
|
|
|
|
// Allocate the GATT notification message
|
|
struct gattc_send_evt_cmd *ntf = KE_MSG_ALLOC_DYN(
|
|
GATTC_SEND_EVT_CMD, KE_BUILD_ID(TASK_GATTC, conidx), dest_id,
|
|
gattc_send_evt_cmd, 2 + param->value.new_alert.info_str_len);
|
|
|
|
// Fill in the parameter structure
|
|
ntf->operation = GATTC_NOTIFY;
|
|
ntf->handle = handle;
|
|
// pack measured value in database
|
|
ntf->length = 2 + param->value.new_alert.info_str_len;
|
|
// Fill data
|
|
memcpy(&ntf->value, ¶m->value.new_alert.cat_id, ntf->length);
|
|
|
|
// The notification can be sent, send the notification
|
|
status = GAP_ERR_NO_ERROR;
|
|
ke_msg_send(ntf);
|
|
} else {
|
|
status = PRF_ERR_NTF_DISABLED;
|
|
break;
|
|
}
|
|
} else {
|
|
if (ANPS_IS_UNREAD_ALERT_CATEGORY_ENABLED(conidx, cat_id, anps_env) &&
|
|
ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_UNREAD_ALERT)) {
|
|
handle = anps_env->shdl + ANS_IDX_UNREAD_ALERT_STATUS_VAL;
|
|
|
|
// Allocate the GATT notification message
|
|
struct gattc_send_evt_cmd *ntf = KE_MSG_ALLOC_DYN(
|
|
GATTC_SEND_EVT_CMD, KE_BUILD_ID(TASK_GATTC, conidx), dest_id,
|
|
gattc_send_evt_cmd, sizeof(struct anp_unread_alert));
|
|
|
|
// Fill in the parameter structure
|
|
ntf->operation = GATTC_NOTIFY;
|
|
ntf->handle = handle;
|
|
// pack measured value in database
|
|
ntf->length = sizeof(struct anp_unread_alert);
|
|
// Fill data
|
|
memcpy(&ntf->value, ¶m->value.unread_alert_status, ntf->length);
|
|
|
|
// The notification can be sent, send the notification
|
|
status = GAP_ERR_NO_ERROR;
|
|
ke_msg_send(ntf);
|
|
} else {
|
|
status = PRF_ERR_NTF_DISABLED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Configure the environment
|
|
anps_env->operation = param->operation;
|
|
// Go to Busy state
|
|
ke_state_set(dest_id, ANPS_BUSY);
|
|
} while (0);
|
|
} else if (state == ANPS_BUSY) {
|
|
// Save it for later
|
|
msg_status = KE_MSG_SAVED;
|
|
status = GAP_ERR_NO_ERROR;
|
|
}
|
|
// no connection
|
|
else {
|
|
status = GAP_ERR_DISCONNECTED;
|
|
}
|
|
|
|
if (status != GAP_ERR_NO_ERROR) {
|
|
// Send the message to the application
|
|
anps_send_cmp_evt(dest_id, src_id, param->operation, status);
|
|
}
|
|
|
|
return (int)msg_status;
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles @ref GATTC_CMP_EVT message meaning that a notification or an
|
|
*indication has been correctly sent to peer device (but not confirmed by peer
|
|
*device).
|
|
*
|
|
* @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 gattc_cmp_evt_handler(ke_msg_id_t const msgid,
|
|
struct gattc_cmp_evt const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id) {
|
|
// Get the address of the environment
|
|
struct anps_env_tag *anps_env = PRF_ENV_GET(ANPS, anps);
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
|
|
if (anps_env != NULL) {
|
|
// Send a complete event status to the application
|
|
anps_send_cmp_evt(prf_src_task_get(&anps_env->prf_env, conidx),
|
|
prf_dst_task_get(&anps_env->prf_env, conidx),
|
|
anps_env->operation, param->status);
|
|
}
|
|
// else ignore the message
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles reception of the read request from peer device
|
|
*
|
|
* @param[in] msgid Id of the message received (probably unused).
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (probably unused).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
__STATIC int gattc_read_req_ind_handler(ke_msg_id_t const msgid,
|
|
struct gattc_read_req_ind const *param,
|
|
ke_task_id_t const dest_id,
|
|
ke_task_id_t const src_id) {
|
|
if (ke_state_get(dest_id) == ANPS_IDLE) {
|
|
// Get the address of the environment
|
|
struct anps_env_tag *anps_env = PRF_ENV_GET(ANPS, anps);
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
uint8_t att_idx = param->handle - anps_env->shdl;
|
|
|
|
uint8_t value[2];
|
|
uint8_t value_size = 0;
|
|
uint8_t status = ATT_ERR_NO_ERROR;
|
|
|
|
switch (att_idx) {
|
|
case ANS_IDX_SUPP_NEW_ALERT_CAT_VAL: {
|
|
// Fill data
|
|
value_size = sizeof(uint16_t);
|
|
co_write16p(value, anps_env->supp_new_alert_cat);
|
|
} break;
|
|
|
|
case ANS_IDX_NEW_ALERT_CFG: {
|
|
// Fill data
|
|
value_size = sizeof(uint16_t);
|
|
co_write16p(value,
|
|
ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_NEW_ALERT));
|
|
} break;
|
|
|
|
case ANS_IDX_SUPP_UNREAD_ALERT_CAT_VAL: {
|
|
// Fill data
|
|
value_size = sizeof(uint16_t);
|
|
co_write16p(value, anps_env->supp_unread_alert_cat);
|
|
} break;
|
|
|
|
case ANS_IDX_UNREAD_ALERT_STATUS_CFG: {
|
|
// Fill data
|
|
value_size = sizeof(uint16_t);
|
|
co_write16p(value,
|
|
ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_UNREAD_ALERT));
|
|
} break;
|
|
|
|
default: {
|
|
status = ATT_ERR_REQUEST_NOT_SUPPORTED;
|
|
} break;
|
|
}
|
|
|
|
// Send data to peer device
|
|
struct gattc_read_cfm *cfm = KE_MSG_ALLOC_DYN(
|
|
GATTC_READ_CFM, src_id, dest_id, gattc_read_cfm, value_size);
|
|
cfm->length = value_size;
|
|
memcpy(cfm->value, value, value_size);
|
|
cfm->handle = param->handle;
|
|
cfm->status = status;
|
|
|
|
// Send value to peer device.
|
|
ke_msg_send(cfm);
|
|
}
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Handles reception of the @ref GATTC_WRITE_REQ_IND message.
|
|
* @param[in] msgid Id of the message received (probably unused).
|
|
* @param[in] param Pointer to the parameters of the message.
|
|
* @param[in] dest_id ID of the receiving task instance (probably unused).
|
|
* @param[in] src_id ID of the sending task instance.
|
|
* @return If the message was consumed or not.
|
|
****************************************************************************************
|
|
*/
|
|
__STATIC int gattc_write_req_ind_handler(
|
|
ke_msg_id_t const msgid, struct gattc_write_req_ind const *param,
|
|
ke_task_id_t const dest_id, ke_task_id_t const src_id) {
|
|
// Status
|
|
uint8_t status = GAP_ERR_NO_ERROR;
|
|
// Get the conidx
|
|
uint8_t conidx = KE_IDX_GET(src_id);
|
|
// Get the address of the environment
|
|
struct anps_env_tag *anps_env = PRF_ENV_GET(ANPS, anps);
|
|
|
|
// Check if the connection exists
|
|
if (anps_env != NULL) {
|
|
/*
|
|
* ---------------------------------------------------------------------------------------------
|
|
* New Alert Client Characteristic Configuration Descriptor Value - Write
|
|
* ---------------------------------------------------------------------------------------------
|
|
* Unread Status Alert Client Characteristic Configuration Descriptor Value
|
|
* - Write
|
|
* ---------------------------------------------------------------------------------------------
|
|
*/
|
|
if ((param->handle == (anps_env->shdl + ANS_IDX_NEW_ALERT_CFG)) ||
|
|
(param->handle == (anps_env->shdl + ANS_IDX_UNREAD_ALERT_STATUS_CFG))) {
|
|
// Received configuration value
|
|
uint16_t ntf_cfg = co_read16p(¶m->value[0]);
|
|
|
|
if (ntf_cfg <= PRF_CLI_START_NTF) {
|
|
// Alert type
|
|
uint8_t alert_type =
|
|
(param->handle == (anps_env->shdl + ANS_IDX_NEW_ALERT_CFG))
|
|
? ANP_NEW_ALERT
|
|
: ANP_UNREAD_ALERT;
|
|
|
|
// Update the status in the environment
|
|
if (ntf_cfg == PRF_CLI_START_NTF) {
|
|
ANPS_ENABLE_ALERT(conidx, anps_env, alert_type);
|
|
} else {
|
|
ANPS_DISABLE_ALERT(conidx, anps_env, alert_type);
|
|
}
|
|
|
|
// Inform the HL that the notification configuration status has been
|
|
// written
|
|
anps_send_ntf_status_update_ind(conidx, anps_env, alert_type);
|
|
// Enable bond Data
|
|
ANPS_ENABLE_ALERT(conidx, anps_env, ANPS_FLAG_CFG_PERFORMED_OK);
|
|
} else {
|
|
status = PRF_APP_ERROR;
|
|
}
|
|
}
|
|
/*
|
|
* ---------------------------------------------------------------------------------------------
|
|
* Alert Notification Control Point Characteristic Value - Write
|
|
* ---------------------------------------------------------------------------------------------
|
|
*/
|
|
else if (param->handle ==
|
|
(anps_env->shdl + ANS_IDX_ALERT_NTF_CTNL_PT_VAL)) {
|
|
do {
|
|
// Check the command ID value
|
|
if (param->value[0] >= CMD_ID_NB) {
|
|
status = ANP_CMD_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
// Check the category ID value
|
|
if ((param->value[1] >= CAT_ID_NB) &&
|
|
(param->value[1] != CAT_ID_ALL_SUPPORTED_CAT)) {
|
|
status = ANP_CAT_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
if (param->value[1] < CAT_ID_NB) {
|
|
// New Alert
|
|
if ((param->value[0] % 2) == 0) {
|
|
// Check if the category is supported
|
|
if (!ANPS_IS_NEW_ALERT_CATEGORY_SUPPORTED(param->value[1])) {
|
|
status = ANP_CAT_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
}
|
|
// Unread Alert Status
|
|
else {
|
|
// Check if the category is supported
|
|
if (!ANPS_IS_UNREAD_ALERT_CATEGORY_SUPPORTED(param->value[1])) {
|
|
status = ANP_CAT_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// React according to the received command id value
|
|
switch (param->value[0]) {
|
|
// Enable New Alert Notification
|
|
case (CMD_ID_EN_NEW_IN_ALERT_NTF): {
|
|
if (param->value[1] != CAT_ID_ALL_SUPPORTED_CAT) {
|
|
// Enable sending of new alert notification for the specified
|
|
// category
|
|
ANPS_ENABLE_NEW_ALERT_CATEGORY(conidx, param->value[1], anps_env);
|
|
} else {
|
|
// Enable sending of new alert notification for all supported
|
|
// category
|
|
anps_env->env[conidx]->ntf_new_alert_cfg |=
|
|
anps_env->supp_new_alert_cat;
|
|
}
|
|
|
|
anps_send_ntf_status_update_ind(conidx, anps_env, ANP_NEW_ALERT);
|
|
} break;
|
|
|
|
// Enable Unread Alert Status Notification
|
|
case (CMD_ID_EN_UNREAD_CAT_STATUS_NTF): {
|
|
if (param->value[1] != CAT_ID_ALL_SUPPORTED_CAT) {
|
|
// Enable sending of unread alert notification for the specified
|
|
// category
|
|
ANPS_ENABLE_UNREAD_ALERT_CATEGORY(conidx, param->value[1],
|
|
anps_env);
|
|
} else {
|
|
// Enable sending of unread alert notification for all supported
|
|
// category
|
|
anps_env->env[conidx]->ntf_unread_alert_cfg |=
|
|
anps_env->supp_unread_alert_cat;
|
|
}
|
|
|
|
anps_send_ntf_status_update_ind(conidx, anps_env, ANP_UNREAD_ALERT);
|
|
} break;
|
|
|
|
// Disable New Alert Notification
|
|
case (CMD_ID_DIS_NEW_IN_ALERT_NTF): {
|
|
if (param->value[1] != CAT_ID_ALL_SUPPORTED_CAT) {
|
|
// Disable sending of new alert notification for the specified
|
|
// category
|
|
ANPS_DISABLE_NEW_ALERT_CATEGORY(conidx, param->value[1], anps_env);
|
|
} else {
|
|
// Disable sending of new alert notification for all supported
|
|
// category
|
|
anps_env->env[conidx]->ntf_new_alert_cfg &=
|
|
~anps_env->supp_new_alert_cat;
|
|
}
|
|
|
|
anps_send_ntf_status_update_ind(conidx, anps_env, ANP_NEW_ALERT);
|
|
} break;
|
|
|
|
// Disable Unread Alert Status Notification
|
|
case (CMD_ID_DIS_UNREAD_CAT_STATUS_NTF): {
|
|
if (param->value[1] != CAT_ID_ALL_SUPPORTED_CAT) {
|
|
// Disable sending of unread alert notification for the specified
|
|
// category
|
|
ANPS_DISABLE_UNREAD_ALERT_CATEGORY(conidx, param->value[1],
|
|
anps_env);
|
|
} else {
|
|
// Enable sending of unread alert notification for all supported
|
|
// category
|
|
anps_env->env[conidx]->ntf_unread_alert_cfg &=
|
|
~anps_env->supp_unread_alert_cat;
|
|
}
|
|
|
|
anps_send_ntf_status_update_ind(conidx, anps_env, ANP_UNREAD_ALERT);
|
|
} break;
|
|
|
|
// Notify New Alert immediately
|
|
case (CMD_ID_NTF_NEW_IN_ALERT_IMM): {
|
|
// Check if sending of notification is enabled
|
|
if (ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_NEW_ALERT)) {
|
|
if (param->value[1] == CAT_ID_ALL_SUPPORTED_CAT) {
|
|
// Check if at least one category can be notified
|
|
if (anps_env->env[conidx]->ntf_new_alert_cfg != 0) {
|
|
anps_send_ntf_immediate_req_ind(conidx, anps_env, ANP_NEW_ALERT,
|
|
CAT_ID_ALL_SUPPORTED_CAT);
|
|
}
|
|
} else {
|
|
// Check if sending of notifications has been enabled for the
|
|
// specified category.
|
|
if (ANPS_IS_NEW_ALERT_CATEGORY_ENABLED(conidx, param->value[1],
|
|
anps_env)) {
|
|
anps_send_ntf_immediate_req_ind(conidx, anps_env, ANP_NEW_ALERT,
|
|
param->value[1]);
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
|
|
// Notify Unread Alert Status immediately
|
|
case (CMD_ID_NTF_UNREAD_CAT_STATUS_IMM): {
|
|
if (ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_UNREAD_ALERT)) {
|
|
// Check if sending of notification is enabled
|
|
if (ANPS_IS_ALERT_ENABLED(conidx, anps_env, ANP_UNREAD_ALERT)) {
|
|
if (param->value[1] == CAT_ID_ALL_SUPPORTED_CAT) {
|
|
// Check if at least one category can be notified
|
|
if (anps_env->env[conidx]->ntf_unread_alert_cfg != 0) {
|
|
anps_send_ntf_immediate_req_ind(conidx, anps_env,
|
|
ANP_UNREAD_ALERT,
|
|
CAT_ID_ALL_SUPPORTED_CAT);
|
|
}
|
|
} else {
|
|
// Check if sending of notifications has been enabled for the
|
|
// specified category.
|
|
if (ANPS_IS_UNREAD_ALERT_CATEGORY_ENABLED(
|
|
conidx, param->value[1], anps_env)) {
|
|
anps_send_ntf_immediate_req_ind(
|
|
conidx, anps_env, ANP_UNREAD_ALERT, param->value[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
|
|
default: {
|
|
ASSERT_ERR(0);
|
|
} break;
|
|
}
|
|
} while (0);
|
|
} else {
|
|
ASSERT_ERR(0);
|
|
}
|
|
// Send the write response to the peer device
|
|
struct gattc_write_cfm *cfm =
|
|
KE_MSG_ALLOC(GATTC_WRITE_CFM, src_id, dest_id, gattc_write_cfm);
|
|
cfm->handle = param->handle;
|
|
cfm->status = status;
|
|
ke_msg_send(cfm);
|
|
}
|
|
// else ignore the message
|
|
|
|
return (KE_MSG_CONSUMED);
|
|
}
|
|
|
|
/*
|
|
* GLOBAL VARIABLE DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// Specifies the default message handlers
|
|
KE_MSG_HANDLER_TAB(anps){
|
|
{ANPS_ENABLE_REQ, (ke_msg_func_t)anps_enable_req_handler},
|
|
{ANPS_NTF_ALERT_CMD, (ke_msg_func_t)anps_ntf_alert_cmd_handler},
|
|
{GATTC_READ_REQ_IND, (ke_msg_func_t)gattc_read_req_ind_handler},
|
|
{GATTC_WRITE_REQ_IND, (ke_msg_func_t)gattc_write_req_ind_handler},
|
|
{GATTC_CMP_EVT, (ke_msg_func_t)gattc_cmp_evt_handler},
|
|
};
|
|
|
|
void anps_task_init(struct ke_task_desc *task_desc) {
|
|
// Get the address of the environment
|
|
struct anps_env_tag *anps_env = PRF_ENV_GET(ANPS, anps);
|
|
|
|
task_desc->msg_handler_tab = anps_msg_handler_tab;
|
|
task_desc->msg_cnt = ARRAY_LEN(anps_msg_handler_tab);
|
|
task_desc->state = anps_env->state;
|
|
task_desc->idx_max = ANPS_IDX_MAX;
|
|
}
|
|
|
|
#endif //(BLE_AN_SERVER)
|
|
|
|
/// @} ANPSTASK
|