/******************************************************************************
##Function Name: CyBle_BlssWriteEventHandler
*******************************************************************************
Summary:
Handles the Write Request Event.
Parameters:
void *eventParam: the pointer to the data structure specified by the event.
Return:
CYBLE_GATT_ERR_CODE_T - An API result state if the API succeeded
(CYBLE_GATT_ERR_NONE) or GATT error codes returned
by CyBle_GattsWriteAttributeValue();
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_BlssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
if(NULL != CyBle_BlsApplCallback)
{
CYBLE_BLS_CHAR_VALUE_T locCharIndex;
locCharIndex.connHandle = eventParam->connHandle;
locCharIndex.value = NULL;
for (locCharIndex.charIndex = CYBLE_BLS_BPM; locCharIndex.charIndex < CYBLE_BLS_BPF; locCharIndex.charIndex++)
{
if(eventParam->handleValPair.attrHandle == cyBle_blss.charInfo[locCharIndex.charIndex].cccdHandle)
{
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair,
0u, &eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
uint32 eventCode;
if(locCharIndex.charIndex == CYBLE_BLS_ICP)
{
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
eventCode = (uint32) CYBLE_EVT_BLSS_NOTIFICATION_ENABLED;
}
else
{
eventCode = (uint32) CYBLE_EVT_BLSS_NOTIFICATION_DISABLED;
}
}
else
{
if(CYBLE_IS_INDICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
eventCode = (uint32) CYBLE_EVT_BLSS_INDICATION_ENABLED;
}
else
{
eventCode = (uint32) CYBLE_EVT_BLSS_INDICATION_DISABLED;
}
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
CyBle_BlsApplCallback(eventCode, &locCharIndex);
}
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
break;
}
}
}
return (gattErr);
}
/******************************************************************************
* Function Name: CyBle_BassWriteEventHandler
***************************************************************************//**
*
* Handles the Write Request Event for Battery service.
*
* \param void *eventParam: the pointer to the data structure specified by the event.
*
* \return
* Return value is of type CYBLE_GATT_ERR_CODE_T.
* * CYBLE_GATT_ERR_NONE - Write request is handled successfully.
* * CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED - Notification isn't supported.
* * CYBLE_GATT_ERR_UNLIKELY_ERROR - Internal error while writing attribute
* value.
*
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_BassWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
uint8 locServIndex = 0u;
CYBLE_BAS_CHAR_VALUE_T locCharIndex;
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
if(NULL != CyBle_BasApplCallback)
{
do
{
/* Client Characteristic Configuration descriptor write request */
if(eventParam->handleValPair.attrHandle == cyBle_bass[locServIndex].cccdHandle)
{
/* Verify that optional notification property is enabled for Battery Level characteristic */
if(CYBLE_IS_NOTIFICATION_SUPPORTED(cyBle_bass[locServIndex].batteryLevelHandle))
{
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
locCharIndex.connHandle = eventParam->connHandle;
locCharIndex.serviceIndex = locServIndex;
locCharIndex.charIndex = CYBLE_BAS_BATTERY_LEVEL;
locCharIndex.value = NULL;
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
CyBle_BasApplCallback((uint32)CYBLE_EVT_BASS_NOTIFICATION_ENABLED, &locCharIndex);
}
else
{
CyBle_BasApplCallback((uint32)CYBLE_EVT_BASS_NOTIFICATION_DISABLED, &locCharIndex);
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
if(cyBle_peerBonding == CYBLE_GAP_BONDING)
{
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
}
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
}
}
else
{
gattErr = CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED;
}
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
break;
}
locServIndex++;
}while(locServIndex < CYBLE_BASS_SERVICE_COUNT);
}
return (gattErr);
}
/******************************************************************************
##Function Name: CyBle_CtssWriteEventHandler
*******************************************************************************
Summary:
Handles the Write Request Event for the Current Time Service.
Parameters:
eventParam: The pointer to the data that came with a write request for the
Current Time Service.
Return:
Return a value of type CYBLE_GATT_ERR_CODE_T:
* CYBLE_GATT_ERR_NONE - Function terminated successfully.
* CYBLE_GATT_ERR_INVALID_HANDLE - The Handle of the Current Time Client
Configuration Characteristic Descriptor
is not valid.
* CYBLE_GATT_ERR_UNLIKELY_ERROR - An Internal Stack error occurred.
* CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED - The notification property of the
Current Time Client Configuration
Characteristic Descriptor is
disabled.
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_CtssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
CYBLE_CTS_CHAR_VALUE_T wrReqParam;
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
uint32 event = (uint32)CYBLE_EVT_CTSS_NOTIFICATION_DISABLED;
if(CyBle_CtsApplCallback != NULL)
{
wrReqParam.connHandle = eventParam->connHandle;
wrReqParam.value = &eventParam->handleValPair.value;
/* Client Characteristic Configuration descriptor write request */
if(eventParam->handleValPair.attrHandle == cyBle_ctss.currTimeCccdHandle)
{
/* Verify that optional notification property is enabled for Current Time
* Characteristic.
*/
if(CYBLE_IS_NOTIFICATION_SUPPORTED(cyBle_ctss.currTimeCharHandle))
{
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
event = (uint32)CYBLE_EVT_CTSS_NOTIFICATION_ENABLED;
}
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
wrReqParam.charIndex = CYBLE_CTS_CURRENT_TIME;
wrReqParam.value = NULL;
CyBle_CtsApplCallback(event, &wrReqParam);
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
#endif /* (CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES)
*/
}
else
{
gattErr = CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED;
}
/* Clear the callback flag indicating that request was handled */
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
}
/******************************************************************************
##Function Name: CyBle_HrssWriteEventHandler
*******************************************************************************
Summary:
Handles the Heart Rate Measurement Client Configuration Characteristic
Descriptor Write Event or Control Point Characteristic Write Event.
Parameters:
void *eventParam: The pointer to the data structure specified by the event.
Return:
None
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_HrssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
uint32 eventCode = 0u;
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
CYBLE_HRS_CHAR_VALUE_T locCharIndex;
locCharIndex.connHandle = eventParam->connHandle;
locCharIndex.value = NULL;
if(eventParam->handleValPair.attrHandle == cyBle_hrss.hrmCccdHandle)
{
locCharIndex.charIndex = CYBLE_HRS_HRM;
/* Heart Rate Measurement characteristic descriptor write request */
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
eventCode = (uint32)CYBLE_EVT_HRSS_NOTIFICATION_ENABLED;
}
else
{
eventCode = (uint32)CYBLE_EVT_HRSS_NOTIFICATION_DISABLED;
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
}
else if(eventParam->handleValPair.attrHandle == cyBle_hrss.charHandle[CYBLE_HRS_CPT])
{
locCharIndex.charIndex = CYBLE_HRS_CPT;
/* Heart Rate Control Point characteristic write request */
if(CYBLE_HRS_RESET_ENERGY_EXPENDED == eventParam->handleValPair.value.val[0u])
{
eventCode = (uint32)CYBLE_EVT_HRSS_ENERGY_EXPENDED_RESET;
}
else
{
gattErr = CYBLE_GATT_ERR_HEART_RATE_CONTROL_POINT_NOT_SUPPORTED;
}
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
}
else
{
/* Heart Rate Service doesn't support any other write requests */
}
if(0u != eventCode)
{
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
if(NULL != CyBle_HrsApplCallback)
{
CyBle_HrsApplCallback(eventCode, &locCharIndex);
}
else
{
CyBle_ApplCallback(CYBLE_EVT_GATTS_WRITE_REQ, eventParam);
}
}
}
return (gattErr);
}
/******************************************************************************
* Function Name: CyBle_AnssWriteEventHandler
***************************************************************************//**
*
* Handles Write Request Event for Alert Notification Service.
*
* \param eventParam: The pointer to the data that came with a write request for
* Alert Notification Service.
*
* \return
* Return a value of type CYBLE_GATT_ERR_CODE_T:
* * CYBLE_GATT_ERR_NONE - The function terminated successfully.
* * CYBLE_GATT_ERR_INVALID_HANDLE - The handle of Client Configuration
* Characteristic Descriptor or Characteristic of Alert Notification Service
* is not valid.
* * CYBLE_GATT_ERR_UNLIKELY_ERROR - An Internal Stack error occurred.
* * CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED - The notification property of a
* specific characteristic of Alert Notification Service is disabled.
*
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_AnssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
CYBLE_ANS_CHAR_VALUE_T wrReqParam;
CYBLE_GATT_DB_ATTR_HANDLE_T tmpHandle;
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
uint8 flag = 0u;
uint32 event = (uint32)CYBLE_EVT_ANSS_CHAR_WRITE;
tmpHandle = eventParam->handleValPair.attrHandle;
/* Client Characteristic Configuration Descriptor Write Request */
if((tmpHandle == cyBle_anss.charInfo[CYBLE_ANS_NEW_ALERT].descrHandle[CYBLE_ANS_CCCD]) ||
(tmpHandle == cyBle_anss.charInfo[CYBLE_ANS_UNREAD_ALERT_STATUS].descrHandle[CYBLE_ANS_CCCD]))
{
/* Verify that optional notification property is enabled for Characteristic */
if(CYBLE_IS_NOTIFICATION_SUPPORTED(cyBle_anss.charInfo[CYBLE_ANS_NEW_ALERT].charHandle) ||
CYBLE_IS_NOTIFICATION_SUPPORTED(cyBle_anss.charInfo[CYBLE_ANS_UNREAD_ALERT_STATUS].charHandle))
{
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
event = (uint32)CYBLE_EVT_ANSS_NOTIFICATION_ENABLED;
}
else
{
event = (uint32)CYBLE_EVT_ANSS_NOTIFICATION_DISABLED;
}
if(tmpHandle == cyBle_anss.charInfo[CYBLE_ANS_NEW_ALERT].descrHandle[CYBLE_ANS_CCCD])
{
wrReqParam.charIndex = CYBLE_ANS_NEW_ALERT;
}
else
{
wrReqParam.charIndex = CYBLE_ANS_UNREAD_ALERT_STATUS;
}
/* Value is NULL for descriptors */
wrReqParam.value = NULL;
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
if(cyBle_peerBonding == CYBLE_GAP_BONDING)
{
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
}
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
}
else
{
gattErr = CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED;
}
}
else if(tmpHandle == cyBle_anss.charInfo[CYBLE_ANS_ALERT_NTF_CONTROL_POINT].charHandle)
{
/* Validate Command ID and Category ID ranges */
if((eventParam->handleValPair.value.val[0u] <= CYBLE_ANS_IMM_UNREAD_ALERT_STATUS_NTF) &&
((eventParam->handleValPair.value.val[1u] <= CYBLE_ANS_CAT_ID_INSTANT_MESSAGE) ||
(eventParam->handleValPair.value.val[1u] == CYBLE_ANS_CAT_ID_ALL)))
{
wrReqParam.charIndex = CYBLE_ANS_ALERT_NTF_CONTROL_POINT;
wrReqParam.value = &eventParam->handleValPair.value;
}
else /* Command ID or Category ID received is invalid */
{
/* Erroneous request won't be notified to user but Error response will be sent. */
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
gattErr = CYBLE_GATT_ERR_ANS_COMMAND_NOT_SUPPORTED;
}
}
else
{
/* Requested handle does not belong to Alert Notification Service
Characteristic or Descriptor. */
flag = 1u;
}
if((gattErr == CYBLE_GATT_ERR_NONE) && (flag == 0u))
{
/* Write value to GATT database */
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(gattErr == CYBLE_GATT_ERR_NONE)
{
wrReqParam.connHandle = eventParam->connHandle;
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
if(NULL != CyBle_AnsApplCallback)
{
CyBle_AnsApplCallback(event, &wrReqParam);
}
}
}
if(CYBLE_GATT_ERR_NONE != gattErr)
{
/* Indicate that request was handled */
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
}
return(gattErr);
}
/******************************************************************************
##Function Name: CyBle_GlssWriteEventHandler
*******************************************************************************
Summary:
Handles the Write Request Event.
Parameters:
*eventParam: The pointer to the data structure specified by the event.
Return:
CYBLE_GATT_ERR_CODE_T - An API result state if the API succeeded
(CYBLE_GATT_ERR_NONE) or failed with error codes:
* CYBLE_GATTS_ERR_PROCEDURE_ALREADY_IN_PROGRESS
* CYBLE_GATTS_ERR_CCCD_IMPROPERLY_CONFIGURED
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_GlssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
CYBLE_GLS_CHAR_VALUE_T locCharValue;
if(NULL != CyBle_GlsApplCallback)
{
locCharValue.connHandle = eventParam->connHandle;
if(eventParam->handleValPair.attrHandle == cyBle_glss.charInfo[CYBLE_GLS_RACP].charHandle)
{
if(CYBLE_GLS_IS_PROCEDURE_IN_PROGRESS
&& (CYBLE_GLS_RACP_OPCODE_ABORT != eventParam->handleValPair.value.val[0u]))
{
gattErr = CYBLE_GATTS_ERR_PROCEDURE_ALREADY_IN_PROGRESS;
}
else if(!CYBLE_IS_INDICATION_ENABLED(cyBle_glss.charInfo[CYBLE_GLS_RACP].cccdHandle))
{
gattErr = CYBLE_GATTS_ERR_CCCD_IMPROPERLY_CONFIGURED;
}
else
{
locCharValue.charIndex = CYBLE_GLS_RACP;
locCharValue.value = &eventParam->handleValPair.value;
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair,
0u, &eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
CyBle_GlsApplCallback((uint32)CYBLE_EVT_GLSS_WRITE_CHAR, &locCharValue);
cyBle_glsFlag |= CYBLE_GLS_FLAG_PROCESS;
}
}
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
}
else
{
for(locCharValue.charIndex = CYBLE_GLS_GLMT;
locCharValue.charIndex < CYBLE_GLS_CHAR_COUNT; locCharValue.charIndex++)
{
if(eventParam->handleValPair.attrHandle == cyBle_glss.charInfo[locCharValue.charIndex].cccdHandle)
{
locCharValue.value = NULL;
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair,
0u, &eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
if(locCharValue.charIndex < CYBLE_GLS_GLFT)
{
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
CyBle_GlsApplCallback((uint32)CYBLE_EVT_GLSS_NOTIFICATION_ENABLED, &locCharValue);
}
else
{
CyBle_GlsApplCallback((uint32)CYBLE_EVT_GLSS_NOTIFICATION_DISABLED, &locCharValue);
}
}
else
{
if(CYBLE_IS_INDICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
CyBle_GlsApplCallback((uint32)CYBLE_EVT_GLSS_INDICATION_ENABLED, &locCharValue);
}
else
{
CyBle_GlsApplCallback((uint32)CYBLE_EVT_GLSS_INDICATION_DISABLED, &locCharValue);
}
}
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
break;
}
}
}
}
return (gattErr);
}
/******************************************************************************
##Function Name: CyBle_WptssWriteEventHandler
*******************************************************************************
Summary:
Handles Write Request Event for Wireless Power Transfer Service.
Parameters:
void *eventParam: The pointer to the data structure specified by the event.
Return:
Return value is of type CYBLE_GATT_ERR_CODE_T.
* CYBLE_GATT_ERR_NONE - Write is successful.
* CYBLE_GATT_ERR_REQUEST_NOT_SUPPORTED - Request is not supported.
* CYBLE_GATT_ERR_INVALID_HANDLE - 'handleValuePair.attrHandle' is not valid.
* CYBLE_GATT_ERR_WRITE_NOT_PERMITTED - Write operation is not permitted on
this attribute.
* CYBLE_GATT_ERR_INVALID_OFFSET - Offset value is invalid.
* CYBLE_GATT_ERR_UNLIKELY_ERROR - Some other error occurred.
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_WptssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
CYBLE_WPTS_CHAR_INDEX_T locCharIndex;
CYBLE_WPTS_CHAR_VALUE_T locCharValue;
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
uint8 locReqHandle = 0u;
if(CyBle_WptsApplCallback != NULL)
{
for(locCharIndex = CYBLE_WPTS_PRU_CONTROL; (locCharIndex < CYBLE_WPTS_CHAR_COUNT) && (locReqHandle == 0u);
locCharIndex++)
{
if((eventParam->handleValPair.attrHandle == cyBle_wptss.charInfo[locCharIndex].descrHandle[CYBLE_WPTS_CCCD])
|| (eventParam->handleValPair.attrHandle == cyBle_wptss.charInfo[locCharIndex].charHandle))
{
locCharValue.connHandle = eventParam->connHandle;
locCharValue.charIndex = locCharIndex;
locCharValue.value = &eventParam->handleValPair.value;
/* Store value to database */
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(gattErr == CYBLE_GATT_ERR_NONE)
{
/* Characteristic value write request */
if(eventParam->handleValPair.attrHandle == cyBle_wptss.charInfo[locCharIndex].charHandle)
{
CyBle_WptsApplCallback((uint32)CYBLE_EVT_WPTSS_WRITE_CHAR, &locCharValue);
}
else /* Client Characteristic Configuration descriptor write request */
{
/* Check characteristic properties for Notification */
if(CYBLE_IS_NOTIFICATION_SUPPORTED(cyBle_wptss.charInfo[locCharIndex].charHandle))
{
uint32 eventCode;
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
eventCode = (uint32)CYBLE_EVT_WPTSS_NOTIFICATION_ENABLED;
}
else
{
eventCode = (uint32)CYBLE_EVT_WPTSS_NOTIFICATION_DISABLED;
}
CyBle_WptsApplCallback(eventCode, &locCharValue);
}
/* Check characteristic properties for Indication */
if(CYBLE_IS_INDICATION_SUPPORTED(cyBle_wptss.charInfo[locCharIndex].charHandle))
{
uint32 eventCode;
if(CYBLE_IS_INDICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
eventCode = (uint32)CYBLE_EVT_WPTSS_INDICATION_ENABLED;
}
else
{
eventCode = (uint32)CYBLE_EVT_WPTSS_INDICATION_DISABLED;
}
CyBle_WptsApplCallback(eventCode, &locCharValue);
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
}
}
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
locReqHandle = 1u;
}
}
}
return (gattErr);
}
/******************************************************************************
##Function Name: CyBle_HtssWriteEventHandler
*******************************************************************************
Summary:
Handles Write Request Event for HTS service.
Parameters:
void *eventParam: The pointer to the data structure specified by the event.
Return:
Return value is of type CYBLE_GATT_ERR_CODE_T.
* CYBLE_GATT_ERR_NONE - Write is successful
******************************************************************************/
CYBLE_GATT_ERR_CODE_T CyBle_HtssWriteEventHandler(CYBLE_GATTS_WRITE_REQ_PARAM_T *eventParam)
{
CYBLE_HTS_CHAR_INDEX_T locCharIndex;
CYBLE_HTS_CHAR_VALUE_T locCharValue;
CYBLE_GATT_ERR_CODE_T gattErr = CYBLE_GATT_ERR_NONE;
uint8 locReqHandle = 0u;
if(NULL != CyBle_HtsApplCallback)
{
for(locCharIndex = CYBLE_HTS_TEMP_MEASURE; (locCharIndex < CYBLE_HTS_CHAR_COUNT) && (locReqHandle == 0u);
locCharIndex++)
{
if((eventParam->handleValPair.attrHandle == cyBle_htss.charInfo[locCharIndex].descrHandle[CYBLE_HTS_CCCD]) ||
(eventParam->handleValPair.attrHandle == cyBle_htss.charInfo[locCharIndex].charHandle))
{
locCharValue.connHandle = eventParam->connHandle;
locCharValue.charIndex = locCharIndex;
locCharValue.value = &eventParam->handleValPair.value;
/* Characteristic value write request */
if(eventParam->handleValPair.attrHandle == cyBle_htss.charInfo[locCharIndex].charHandle)
{
/* Validate Measure Interval value */
if(locCharIndex == CYBLE_HTS_MEASURE_INTERVAL)
{
uint8 locAttrValue[CYBLE_HTS_VRD_LEN];
uint16 requestValue;
requestValue = CyBle_Get16ByPtr(eventParam->handleValPair.value.val);
if(requestValue != 0u) /* 0 is valid interval value for no periodic measurement */
{
/* Check Valid range for Measure Interval characteristic value */
if(CYBLE_ERROR_OK == CyBle_HtssGetCharacteristicDescriptor(locCharIndex, CYBLE_HTS_VRD,
CYBLE_HTS_VRD_LEN, locAttrValue))
{
uint16 lowerValue;
uint16 upperValue;
lowerValue = CyBle_Get16ByPtr(locAttrValue);
upperValue = CyBle_Get16ByPtr(locAttrValue + sizeof(lowerValue));
requestValue = CyBle_Get16ByPtr(eventParam->handleValPair.value.val);
if((requestValue != 0u) && ((requestValue < lowerValue) || (requestValue > upperValue)))
{
gattErr = CYBLE_GATT_ERR_HTS_OUT_OF_RANGE;
}
}
}
}
if(CYBLE_GATT_ERR_NONE == gattErr)
{ /* Store value to database */
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
CyBle_HtsApplCallback((uint32)CYBLE_EVT_HTSS_CHAR_WRITE, &locCharValue);
}
}
}
else /* Client Characteristic Configuration descriptor write request */
{
/* Store value to database */
gattErr = CyBle_GattsWriteAttributeValue(&eventParam->handleValPair, 0u,
&eventParam->connHandle, CYBLE_GATT_DB_PEER_INITIATED);
if(CYBLE_GATT_ERR_NONE == gattErr)
{
/* Check characteristic properties for Notification */
if(CYBLE_IS_NOTIFICATION_SUPPORTED(cyBle_htss.charInfo[locCharIndex].charHandle))
{
if(CYBLE_IS_NOTIFICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
CyBle_HtsApplCallback((uint32)CYBLE_EVT_HTSS_NOTIFICATION_ENABLED, &locCharValue);
}
else
{
CyBle_HtsApplCallback((uint32)CYBLE_EVT_HTSS_NOTIFICATION_DISABLED, &locCharValue);
}
}
/* Check characteristic properties for Indication */
if(CYBLE_IS_INDICATION_SUPPORTED(cyBle_htss.charInfo[locCharIndex].charHandle))
{
if(CYBLE_IS_INDICATION_ENABLED_IN_PTR(eventParam->handleValPair.value.val))
{
CyBle_HtsApplCallback((uint32)CYBLE_EVT_HTSS_INDICATION_ENABLED, &locCharValue);
}
else
{
CyBle_HtsApplCallback((uint32)CYBLE_EVT_HTSS_INDICATION_DISABLED, &locCharValue);
}
}
#if((CYBLE_GAP_ROLE_PERIPHERAL || CYBLE_GAP_ROLE_CENTRAL) && \
(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES))
/* Set flag to store bonding data to flash */
cyBle_pendingFlashWrite |= CYBLE_PENDING_CCCD_FLASH_WRITE_BIT;
#endif /* (CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES) */
}
}
cyBle_eventHandlerFlag &= (uint8)~CYBLE_CALLBACK;
locReqHandle = 1u;
}
}
}
return (gattErr);
}
