diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c')
-rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.c | 575 | ||||
-rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.h | 409 |
2 files changed, 984 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.c new file mode 100644 index 0000000..9fc8ad6 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.c @@ -0,0 +1,575 @@ +/** + * Copyright (c) 2012 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +/* Attention! + * To maintain compliance with Nordic Semiconductor ASA's Bluetooth profile + * qualification listings, this section of source code must not be modified. + */ +#include "sdk_common.h" +#if NRF_MODULE_ENABLED(BLE_ANS_C) +#include "ble_ans_c.h" +#include <string.h> +#include <stdbool.h> +#include "ble_err.h" +#include "nrf_assert.h" +#include "ble_db_discovery.h" +#define NRF_LOG_MODULE_NAME ble_ans_c +#include "nrf_log.h" +NRF_LOG_MODULE_REGISTER(); + +#define NOTIFICATION_DATA_LENGTH 2 /**< The mandatory length of notification data. After the mandatory data, the optional message is located. */ +#define READ_DATA_LENGTH_MIN 1 /**< Minimum data length in a valid Alert Notification Read Response message. */ + +#define TX_BUFFER_MASK 0x07 /**< TX Buffer mask, must be a mask of contiguous zeroes, followed by contiguous sequence of ones: 000...111. */ +#define TX_BUFFER_SIZE (TX_BUFFER_MASK + 1) /**< Size of send buffer, which is 1 higher than the mask. */ +#define WRITE_MESSAGE_LENGTH 2 /**< Length of the write message for CCCD/control point. */ + + +typedef enum +{ + READ_REQ = 1, /**< Type identifying that this tx_message is a read request. */ + WRITE_REQ /**< Type identifying that this tx_message is a write request. */ +} ans_tx_request_t; + + +/**@brief Structure for writing a message to the central, i.e. Control Point or CCCD. + */ +typedef struct +{ + uint8_t gattc_value[WRITE_MESSAGE_LENGTH]; /**< The message to write. */ + ble_gattc_write_params_t gattc_params; /**< GATTC parameters for this message. */ +} ans_write_params_t; + +/**@brief Structure for holding data to be transmitted to the connected central. + */ +typedef struct +{ + uint16_t conn_handle; /**< Connection handle to be used when transmitting this message. */ + ans_tx_request_t type; /**< Type of this message, i.e. read or write message. */ + union + { + uint16_t read_handle; /**< Read request message. */ + ans_write_params_t write_req; /**< Write request message. */ + } req; +} ans_tx_message_t; + +static ans_tx_message_t m_tx_buffer[TX_BUFFER_SIZE]; /**< Transmit buffer for messages to be transmitted to the central. */ +static uint32_t m_tx_insert_index = 0; /**< Current index in the transmit buffer where next message should be inserted. */ +static uint32_t m_tx_index = 0; /**< Current index in the transmit buffer from where the next message to be transmitted resides. */ + + +/**@brief Function for passing any pending request from the buffer to the stack. + */ +static void tx_buffer_process(void) +{ + if (m_tx_index != m_tx_insert_index) + { + uint32_t err_code; + + if (m_tx_buffer[m_tx_index].type == READ_REQ) + { + err_code = sd_ble_gattc_read(m_tx_buffer[m_tx_index].conn_handle, + m_tx_buffer[m_tx_index].req.read_handle, + 0); + } + else + { + err_code = sd_ble_gattc_write(m_tx_buffer[m_tx_index].conn_handle, + &m_tx_buffer[m_tx_index].req.write_req.gattc_params); + } + if (err_code == NRF_SUCCESS) + { + ++m_tx_index; + m_tx_index &= TX_BUFFER_MASK; + } + } +} + + +/** @brief Function for copying a characteristic. + */ +static void char_set(ble_gattc_char_t * p_dest_char, ble_gattc_char_t const * p_source_char) +{ + memcpy(p_dest_char, p_source_char, sizeof(ble_gattc_char_t)); +} + +static void char_cccd_set(ble_gattc_desc_t * p_cccd, uint16_t cccd_handle) +{ + p_cccd->handle = cccd_handle; +} + +/** @brief Function to check that all handles required by the client to use the server are present. + */ +static bool is_valid_ans_srv_discovered(ble_ans_c_service_t const * p_srv) +{ + if ((p_srv->alert_notif_ctrl_point.handle_value == BLE_GATT_HANDLE_INVALID) || + (p_srv->suported_new_alert_cat.handle_value == BLE_GATT_HANDLE_INVALID) || + (p_srv->suported_unread_alert_cat.handle_value == BLE_GATT_HANDLE_INVALID) || + (p_srv->new_alert.handle_value == BLE_GATT_HANDLE_INVALID) || + (p_srv->unread_alert_status.handle_value == BLE_GATT_HANDLE_INVALID) || + (p_srv->new_alert_cccd.handle == BLE_GATT_HANDLE_INVALID) || + (p_srv->unread_alert_cccd.handle == BLE_GATT_HANDLE_INVALID) + ) + { + // At least one required characteristic is missing on the server side. + return false; + } + return true; +} + + +void ble_ans_c_on_db_disc_evt(ble_ans_c_t * p_ans, ble_db_discovery_evt_t const * p_evt) +{ + ble_ans_c_evt_t evt; + + memset(&evt, 0, sizeof(ble_ans_c_evt_t)); + evt.conn_handle = p_evt->conn_handle; + evt.evt_type = BLE_ANS_C_EVT_DISCOVERY_FAILED; + + // Check if the Alert Notification Service was discovered. + if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE + && + p_evt->params.discovered_db.srv_uuid.uuid == BLE_UUID_ALERT_NOTIFICATION_SERVICE + && + p_evt->params.discovered_db.srv_uuid.type == BLE_UUID_TYPE_BLE) + { + // Find the characteristics inside the service. + for (uint8_t i = 0; i < p_evt->params.discovered_db.char_count; i++) + { + ble_gatt_db_char_t const * p_char = &(p_evt->params.discovered_db.charateristics[i]); + + switch (p_char->characteristic.uuid.uuid) + { + case BLE_UUID_ALERT_NOTIFICATION_CONTROL_POINT_CHAR: + NRF_LOG_DEBUG("Found Ctrlpt \r\n\r"); + char_set(&evt.data.service.alert_notif_ctrl_point, &p_char->characteristic); + break; + + case BLE_UUID_UNREAD_ALERT_CHAR: + NRF_LOG_DEBUG("Found Unread Alert \r\n\r"); + char_set(&evt.data.service.unread_alert_status, &p_char->characteristic); + char_cccd_set(&evt.data.service.unread_alert_cccd, + p_char->cccd_handle); + break; + + case BLE_UUID_NEW_ALERT_CHAR: + NRF_LOG_DEBUG("Found New Alert \r\n\r"); + char_set(&evt.data.service.new_alert, &p_char->characteristic); + char_cccd_set(&evt.data.service.new_alert_cccd, + p_char->cccd_handle); + break; + + case BLE_UUID_SUPPORTED_UNREAD_ALERT_CATEGORY_CHAR: + NRF_LOG_DEBUG("Found supported unread alert category \r\n\r"); + char_set(&evt.data.service.suported_unread_alert_cat, &p_char->characteristic); + break; + + case BLE_UUID_SUPPORTED_NEW_ALERT_CATEGORY_CHAR: + NRF_LOG_DEBUG("Found supported new alert category \r\n\r"); + char_set(&evt.data.service.suported_new_alert_cat, &p_char->characteristic); + break; + + default: + // No implementation needed. + break; + } + } + if (is_valid_ans_srv_discovered(&evt.data.service)) + { + evt.evt_type = BLE_ANS_C_EVT_DISCOVERY_COMPLETE; + } + } + p_ans->evt_handler(&evt); +} + + +/**@brief Function for receiving and validating notifications received from the central. + */ +static void event_notify(ble_ans_c_t * p_ans, ble_evt_t const * p_ble_evt) +{ + uint32_t message_length; + ble_ans_c_evt_t event; + ble_ans_alert_notification_t * p_alert = &event.data.alert; + ble_gattc_evt_hvx_t const * p_notification = &p_ble_evt->evt.gattc_evt.params.hvx; + + // Message is not valid -> ignore. + event.evt_type = BLE_ANS_C_EVT_NOTIFICATION; + if (p_notification->len < NOTIFICATION_DATA_LENGTH) + { + return; + } + message_length = p_notification->len - NOTIFICATION_DATA_LENGTH; + + if (p_notification->handle == p_ans->service.new_alert.handle_value) + { + BLE_UUID_COPY_INST(event.uuid, p_ans->service.new_alert.uuid); + } + else if (p_notification->handle == p_ans->service.unread_alert_status.handle_value) + { + BLE_UUID_COPY_INST(event.uuid, p_ans->service.unread_alert_status.uuid); + } + else + { + // Nothing to process. + return; + } + + p_alert->alert_category = p_notification->data[0]; + p_alert->alert_category_count = p_notification->data[1]; //lint !e415 + p_alert->alert_msg_length = (message_length > p_ans->message_buffer_size) + ? p_ans->message_buffer_size + : message_length; + p_alert->p_alert_msg_buf = p_ans->p_message_buffer; + + memcpy(p_alert->p_alert_msg_buf, + &p_notification->data[NOTIFICATION_DATA_LENGTH], + p_alert->alert_msg_length); //lint !e416 + + p_ans->evt_handler(&event); +} + + +/**@brief Function for handling write response events. + */ +static void event_write_rsp(ble_ans_c_t * p_ans, ble_evt_t const * p_ble_evt) +{ + tx_buffer_process(); +} + + +/**@brief Function for validating and passing the response to the application, + * when a read response is received. + */ +static void event_read_rsp(ble_ans_c_t * p_ans, ble_evt_t const * p_ble_evt) +{ + ble_ans_c_evt_t event; + ble_gattc_evt_read_rsp_t const * p_response; + + p_response = &p_ble_evt->evt.gattc_evt.params.read_rsp; + event.evt_type = BLE_ANS_C_EVT_READ_RESP; + + if (p_response->len < READ_DATA_LENGTH_MIN) + { + tx_buffer_process(); + return; + } + + if (p_response->handle == p_ans->service.suported_new_alert_cat.handle_value) + { + BLE_UUID_COPY_INST(event.uuid, p_ans->service.suported_new_alert_cat.uuid); + } + else if (p_response->handle == p_ans->service.suported_unread_alert_cat.handle_value) + { + BLE_UUID_COPY_INST(event.uuid, p_ans->service.suported_unread_alert_cat.uuid); + } + else + { + // Bad response, ignore. + tx_buffer_process(); + return; + } + + event.data.settings = *(ble_ans_alert_settings_t *)(p_response->data); + + if (p_response->len == READ_DATA_LENGTH_MIN) + { + // Those must default to 0, if they are not returned by central. + event.data.settings.ans_high_prioritized_alert_support = 0; + event.data.settings.ans_instant_message_support = 0; + } + + p_ans->evt_handler(&event); + + tx_buffer_process(); +} + + +/**@brief Function for disconnecting and cleaning the current service. + */ +static void event_disconnect(ble_ans_c_t * p_ans, ble_evt_t const * p_ble_evt) +{ + if (p_ans->conn_handle == p_ble_evt->evt.gap_evt.conn_handle) + { + p_ans->conn_handle = BLE_CONN_HANDLE_INVALID; + + // Clearing all data for the service will also set all handle values to @ref BLE_GATT_HANDLE_INVALID + memset(&p_ans->service, 0, sizeof(ble_ans_c_service_t)); + + // There was a valid instance of IAS on the peer. Send an event to the + // application, so that it can do any clean up related to this module. + ble_ans_c_evt_t evt; + + evt.evt_type = BLE_ANS_C_EVT_DISCONN_COMPLETE; + p_ans->evt_handler(&evt); + } +} + + +/**@brief Function for handling of BLE stack events. */ +void ble_ans_c_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context) +{ + ble_ans_c_t * p_ans = (ble_ans_c_t *)p_context; + + switch (p_ble_evt->header.evt_id) + { + case BLE_GATTC_EVT_HVX: + event_notify(p_ans, p_ble_evt); + break; + + case BLE_GATTC_EVT_WRITE_RSP: + event_write_rsp(p_ans, p_ble_evt); + break; + + case BLE_GATTC_EVT_READ_RSP: + event_read_rsp(p_ans, p_ble_evt); + break; + + case BLE_GAP_EVT_DISCONNECTED: + event_disconnect(p_ans, p_ble_evt); + break; + } +} + + +uint32_t ble_ans_c_init(ble_ans_c_t * p_ans, ble_ans_c_init_t const * p_ans_init) +{ + VERIFY_PARAM_NOT_NULL(p_ans); + VERIFY_PARAM_NOT_NULL(p_ans_init); + VERIFY_PARAM_NOT_NULL(p_ans_init->evt_handler); + + // clear all handles + memset(p_ans, 0, sizeof(ble_ans_c_t)); + memset(m_tx_buffer, 0, TX_BUFFER_SIZE); + p_ans->conn_handle = BLE_CONN_HANDLE_INVALID; + + p_ans->evt_handler = p_ans_init->evt_handler; + p_ans->error_handler = p_ans_init->error_handler; + p_ans->message_buffer_size = p_ans_init->message_buffer_size; + p_ans->p_message_buffer = p_ans_init->p_message_buffer; + + BLE_UUID_BLE_ASSIGN(p_ans->service.service.uuid, BLE_UUID_ALERT_NOTIFICATION_SERVICE); + BLE_UUID_BLE_ASSIGN(p_ans->service.new_alert.uuid, BLE_UUID_NEW_ALERT_CHAR); + BLE_UUID_BLE_ASSIGN(p_ans->service.alert_notif_ctrl_point.uuid, + BLE_UUID_ALERT_NOTIFICATION_CONTROL_POINT_CHAR); + BLE_UUID_BLE_ASSIGN(p_ans->service.unread_alert_status.uuid, BLE_UUID_UNREAD_ALERT_CHAR); + BLE_UUID_BLE_ASSIGN(p_ans->service.suported_new_alert_cat.uuid, + BLE_UUID_SUPPORTED_NEW_ALERT_CATEGORY_CHAR); + BLE_UUID_BLE_ASSIGN(p_ans->service.suported_unread_alert_cat.uuid, + BLE_UUID_SUPPORTED_UNREAD_ALERT_CATEGORY_CHAR); + + BLE_UUID_BLE_ASSIGN(p_ans->service.new_alert_cccd.uuid, BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG); + BLE_UUID_BLE_ASSIGN(p_ans->service.unread_alert_cccd.uuid, + BLE_UUID_DESCRIPTOR_CLIENT_CHAR_CONFIG); + + return ble_db_discovery_evt_register(&p_ans->service.service.uuid); +} + + +/**@brief Function for creating a TX message for writing a CCCD. + */ +static uint32_t cccd_configure(uint16_t conn_handle, uint16_t handle_cccd, bool enable) +{ + ans_tx_message_t * p_msg; + uint16_t cccd_val = enable ? BLE_GATT_HVX_NOTIFICATION : 0; + + p_msg = &m_tx_buffer[m_tx_insert_index++]; + m_tx_insert_index &= TX_BUFFER_MASK; + + p_msg->req.write_req.gattc_params.handle = handle_cccd; + p_msg->req.write_req.gattc_params.len = WRITE_MESSAGE_LENGTH; + p_msg->req.write_req.gattc_params.p_value = p_msg->req.write_req.gattc_value; + p_msg->req.write_req.gattc_params.offset = 0; + p_msg->req.write_req.gattc_params.write_op = BLE_GATT_OP_WRITE_REQ; + p_msg->req.write_req.gattc_value[0] = LSB_16(cccd_val); + p_msg->req.write_req.gattc_value[1] = MSB_16(cccd_val); + p_msg->conn_handle = conn_handle; + p_msg->type = WRITE_REQ; + + tx_buffer_process(); + return NRF_SUCCESS; +} + + +uint32_t ble_ans_c_enable_notif_new_alert(ble_ans_c_t const * p_ans) +{ + if (p_ans->conn_handle == BLE_CONN_HANDLE_INVALID) + { + return NRF_ERROR_INVALID_STATE; + } + else + { + return cccd_configure(p_ans->conn_handle, + p_ans->service.new_alert_cccd.handle, + true); + } +} + + +uint32_t ble_ans_c_disable_notif_new_alert(ble_ans_c_t const * p_ans) +{ + return cccd_configure(p_ans->conn_handle, + p_ans->service.new_alert_cccd.handle, + false); +} + + +uint32_t ble_ans_c_enable_notif_unread_alert(ble_ans_c_t const * p_ans) +{ + if ( p_ans->conn_handle == BLE_CONN_HANDLE_INVALID) + { + return NRF_ERROR_INVALID_STATE; + } + return cccd_configure(p_ans->conn_handle, + p_ans->service.unread_alert_cccd.handle, + true); +} + + +uint32_t ble_ans_c_disable_notif_unread_alert(ble_ans_c_t const * p_ans) +{ + return cccd_configure(p_ans->conn_handle, + p_ans->service.unread_alert_cccd.handle, + false); +} + + +uint32_t ble_ans_c_control_point_write(ble_ans_c_t const * p_ans, + ble_ans_control_point_t const * p_control_point) +{ + ans_tx_message_t * p_msg; + + p_msg = &m_tx_buffer[m_tx_insert_index++]; + m_tx_insert_index &= TX_BUFFER_MASK; + + p_msg->req.write_req.gattc_params.handle = p_ans->service.alert_notif_ctrl_point.handle_value; + p_msg->req.write_req.gattc_params.len = WRITE_MESSAGE_LENGTH; + p_msg->req.write_req.gattc_params.p_value = p_msg->req.write_req.gattc_value; + p_msg->req.write_req.gattc_params.offset = 0; + p_msg->req.write_req.gattc_params.write_op = BLE_GATT_OP_WRITE_REQ; + p_msg->req.write_req.gattc_value[0] = p_control_point->command; + p_msg->req.write_req.gattc_value[1] = p_control_point->category; + p_msg->conn_handle = p_ans->conn_handle; + p_msg->type = WRITE_REQ; + + tx_buffer_process(); + return NRF_SUCCESS; +} + + +uint32_t ble_ans_c_new_alert_read(ble_ans_c_t const * p_ans) +{ + ans_tx_message_t * msg; + + msg = &m_tx_buffer[m_tx_insert_index++]; + m_tx_insert_index &= TX_BUFFER_MASK; + + msg->req.read_handle = p_ans->service.suported_new_alert_cat.handle_value; + msg->conn_handle = p_ans->conn_handle; + msg->type = READ_REQ; + + tx_buffer_process(); + return NRF_SUCCESS; +} + + +uint32_t ble_ans_c_unread_alert_read(ble_ans_c_t const * p_ans) +{ + ans_tx_message_t * msg; + + msg = &m_tx_buffer[m_tx_insert_index++]; + m_tx_insert_index &= TX_BUFFER_MASK; + + msg->req.read_handle = p_ans->service.suported_unread_alert_cat.handle_value; + msg->conn_handle = p_ans->conn_handle; + msg->type = READ_REQ; + + tx_buffer_process(); + return NRF_SUCCESS; +} + + +uint32_t ble_ans_c_new_alert_notify(ble_ans_c_t const * p_ans, ble_ans_category_id_t category_id) +{ + ble_ans_control_point_t control_point; + + control_point.command = ANS_NOTIFY_NEW_INCOMING_ALERT_IMMEDIATELY; + control_point.category = category_id; + + return ble_ans_c_control_point_write(p_ans, &control_point); +} + + +uint32_t ble_ans_c_unread_alert_notify(ble_ans_c_t const * p_ans, ble_ans_category_id_t category_id) +{ + ble_ans_control_point_t control_point; + + control_point.command = ANS_NOTIFY_UNREAD_CATEGORY_STATUS_IMMEDIATELY; + control_point.category = category_id; + + return ble_ans_c_control_point_write(p_ans, &control_point); +} + + +uint32_t ble_ans_c_handles_assign(ble_ans_c_t * p_ans, + uint16_t conn_handle, + ble_ans_c_service_t const * p_peer_handles) +{ + VERIFY_PARAM_NOT_NULL(p_ans); + + if (!is_valid_ans_srv_discovered(p_peer_handles)) + { + return NRF_ERROR_INVALID_PARAM; + } + p_ans->conn_handle = conn_handle; + + if (p_peer_handles != NULL) + { + // Copy the handles from the discovered characteristics over to the provided client instance. + char_set(&p_ans->service.alert_notif_ctrl_point, &p_peer_handles->alert_notif_ctrl_point); + char_set(&p_ans->service.suported_new_alert_cat, &p_peer_handles->suported_new_alert_cat); + char_set(&p_ans->service.suported_unread_alert_cat, &p_peer_handles->suported_unread_alert_cat); + char_set(&p_ans->service.new_alert, &p_peer_handles->new_alert); + char_cccd_set(&p_ans->service.new_alert_cccd, p_peer_handles->new_alert_cccd.handle); + char_set(&p_ans->service.unread_alert_status, &p_peer_handles->unread_alert_status); + char_cccd_set(&p_ans->service.unread_alert_cccd, p_peer_handles->unread_alert_cccd.handle); + } + + return NRF_SUCCESS; +} +#endif // NRF_MODULE_ENABLED(BLE_ANS_C) diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.h new file mode 100644 index 0000000..642cffd --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ans_c/ble_ans_c.h @@ -0,0 +1,409 @@ +/** + * Copyright (c) 2012 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +/** @file + * + * @defgroup ble_ans_c Alert Notification Service Client + * @{ + * @ingroup ble_sdk_srv + * @brief Alert Notification module. + * + * @details This module implements the Alert Notification Client according to the + * Alert Notification Profile. + * + * @note The application must register this module as BLE event observer using the + * NRF_SDH_BLE_OBSERVER macro. Example: + * @code + * ble_ans_c_t instance; + * NRF_SDH_BLE_OBSERVER(anything, BLE_ANS_C_BLE_OBSERVER_PRIO, + * ble_ans_c_on_ble_evt, &instance); + * @endcode + * + * @note Attention! + * To maintain compliance with Nordic Semiconductor ASA Bluetooth profile + * qualification listings, this section of source code must not be modified. + */ +#ifndef BLE_ANS_C_H__ +#define BLE_ANS_C_H__ + +#include "ble.h" +#include "ble_gatts.h" +#include "ble_types.h" +#include "sdk_common.h" +#include "ble_srv_common.h" +#include "ble_db_discovery.h" +#include "nrf_sdh_ble.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/**@brief Macro for defining a ble_ans_c instance. + * + * @param _name Name of the instance. + * @hideinitializer + */ +#define BLE_ANS_C_DEF(_name) \ +static ble_ans_c_t _name; \ +NRF_SDH_BLE_OBSERVER(_name ## _obs, \ + BLE_ANS_C_BLE_OBSERVER_PRIO, \ + ble_ans_c_on_ble_evt, &_name) + +/** @brief Macro for defining multiple ble_ans_c instances. + * + * @param _name Name of the array of instances. + * @param _cnt Number of instances to define. + * @hideinitializer + */ +#define BLE_ANS_C_ARRAY_DEF(_name, _cnt) \ +static ble_ans_c_t _name[_cnt]; \ +NRF_SDH_BLE_OBSERVERS(_name ## _obs, \ + BLE_ANS_C_BLE_OBSERVER_PRIO, \ + ble_ans_c_on_ble_evt, &_name, _cnt) + +// Forward declaration of the ble_ans_c_t type. +typedef struct ble_ans_c_s ble_ans_c_t; + +/** Alerts types as defined in the alert category id; UUID: 0x2A43. */ +typedef enum +{ + ANS_TYPE_SIMPLE_ALERT = 0, /**< General text alert or non-text alert.*/ + ANS_TYPE_EMAIL = 1, /**< Alert when email messages arrives.*/ + ANS_TYPE_NEWS = 2, /**< News feeds such as RSS, Atom.*/ + ANS_TYPE_NOTIFICATION_CALL = 3, /**< Incoming call.*/ + ANS_TYPE_MISSED_CALL = 4, /**< Missed call.*/ + ANS_TYPE_SMS_MMS = 5, /**< SMS/MMS message arrives.*/ + ANS_TYPE_VOICE_MAIL = 6, /**< Voice mail.*/ + ANS_TYPE_SCHEDULE = 7, /**< Alert occurred on calendar, planner.*/ + ANS_TYPE_HIGH_PRIORITIZED_ALERT = 8, /**< Alert that should be handled as high priority.*/ + ANS_TYPE_INSTANT_MESSAGE = 9, /**< Alert for incoming instant messages.*/ + ANS_TYPE_ALL_ALERTS = 0xFF /**< Identifies All Alerts. */ +} ble_ans_category_id_t; + +/** Alerts notification control point commands as defined in the Alert Notification Specification; + * UUID: 0x2A44. + */ +typedef enum +{ + ANS_ENABLE_NEW_INCOMING_ALERT_NOTIFICATION = 0, /**< Enable New Incoming Alert Notification.*/ + ANS_ENABLE_UNREAD_CATEGORY_STATUS_NOTIFICATION = 1, /**< Enable Unread Category Status Notification.*/ + ANS_DISABLE_NEW_INCOMING_ALERT_NOTIFICATION = 2, /**< Disable New Incoming Alert Notification.*/ + ANS_DISABLE_UNREAD_CATEGORY_STATUS_NOTIFICATION = 3, /**< Disable Unread Category Status Notification.*/ + ANS_NOTIFY_NEW_INCOMING_ALERT_IMMEDIATELY = 4, /**< Notify New Incoming Alert immediately.*/ + ANS_NOTIFY_UNREAD_CATEGORY_STATUS_IMMEDIATELY = 5, /**< Notify Unread Category Status immediately.*/ +} ble_ans_command_id_t; + +/**@brief Alert Notification Event types that are passed from client to application on an event. */ +typedef enum +{ + BLE_ANS_C_EVT_DISCOVERY_COMPLETE, /**< A successful connection has been established and the characteristics of the server has been fetched. */ + BLE_ANS_C_EVT_DISCOVERY_FAILED, /**< It was not possible to discover service or characteristics of the connected peer. */ + BLE_ANS_C_EVT_DISCONN_COMPLETE, /**< The connection has been taken down. */ + BLE_ANS_C_EVT_NOTIFICATION, /**< A valid Alert Notification has been received from the server.*/ + BLE_ANS_C_EVT_READ_RESP, /**< A read response has been received from the server.*/ + BLE_ANS_C_EVT_WRITE_RESP /**< A write response has been received from the server.*/ +} ble_ans_c_evt_type_t; + +/**@brief Alert Notification Control Point structure. */ +typedef struct +{ + ble_ans_command_id_t command; /**< The command to be written to the control point, see @ref ble_ans_command_id_t. */ + ble_ans_category_id_t category; /**< The category for the control point for which the command applies, see @ref ble_ans_category_id_t. */ +} ble_ans_control_point_t; + +/**@brief Alert Notification Setting structure containing the supported alerts in the service. + * + *@details + * The structure contains bit fields describing which alerts that are supported: + * 0 = Unsupported + * 1 = Supported + */ +typedef struct +{ + uint8_t ans_simple_alert_support : 1; /**< Support for General text alert or non-text alert.*/ + uint8_t ans_email_support : 1; /**< Support for Alert when email messages arrives.*/ + uint8_t ans_news_support : 1; /**< Support for News feeds such as RSS, Atom.*/ + uint8_t ans_notification_call_support : 1; /**< Support for Incoming call.*/ + uint8_t ans_missed_call_support : 1; /**< Support for Missed call.*/ + uint8_t ans_sms_mms_support : 1; /**< Support for SMS/MMS message arrives.*/ + uint8_t ans_voice_mail_support : 1; /**< Support for Voice mail.*/ + uint8_t ans_schedule_support : 1; /**< Support for Alert occurred on calendar, planner.*/ + uint8_t ans_high_prioritized_alert_support : 1; /**< Support for Alert that should be handled as high priority.*/ + uint8_t ans_instant_message_support : 1; /**< Support for Alert for incoming instant messages.*/ + uint8_t reserved : 6; /**< Reserved for future use. */ +} ble_ans_alert_settings_t; + +/**@brief Alert Notification structure + */ +typedef struct +{ + uint8_t alert_category; /**< Alert category to which this alert belongs.*/ + uint8_t alert_category_count; /**< Number of alerts in the category. */ + uint32_t alert_msg_length; /**< Length of optional text message send by the server. */ + uint8_t * p_alert_msg_buf; /**< Pointer to buffer containing the optional text message. */ +} ble_ans_alert_notification_t; + +/**@brief Struct to hold information on the Alert Notification Service if found on the server. */ +typedef struct +{ + ble_gattc_service_t service; /**< The GATT service holding the discovered Alert Notification Service. */ + ble_gattc_char_t alert_notif_ctrl_point; /**< Characteristic for the Alert Notification Control Point. @ref BLE_UUID_ALERT_NOTIFICATION_CONTROL_POINT_CHAR */ + ble_gattc_char_t suported_new_alert_cat; /**< Characteristic for the Supported New Alert category. @ref BLE_UUID_SUPPORTED_NEW_ALERT_CATEGORY_CHAR */ + ble_gattc_char_t suported_unread_alert_cat; /**< Characteristic for the Unread Alert category. @ref BLE_UUID_SUPPORTED_UNREAD_ALERT_CATEGORY_CHAR */ + ble_gattc_char_t new_alert; /**< Characteristic for the New Alert Notification. @ref BLE_UUID_NEW_ALERT_CHAR */ + ble_gattc_desc_t new_alert_cccd; /**< Characteristic Descriptor for New Alert Category. Enables or Disables GATT notifications */ + ble_gattc_char_t unread_alert_status; /**< Characteristic for the Unread Alert Notification. @ref BLE_UUID_UNREAD_ALERT_CHAR */ + ble_gattc_desc_t unread_alert_cccd; /**< Characteristic Descriptor for Unread Alert Category. Enables or Disables GATT notifications */ +} ble_ans_c_service_t; + +/**@brief Alert Notification Event structure + * + * @details The structure contains the event that should be handled, as well as + * additional information. + */ +typedef struct +{ + ble_ans_c_evt_type_t evt_type; /**< Type of event. */ + uint16_t conn_handle; /**< Connection handle on which the ANS service was discovered on the peer device. This will be filled if the evt_type is @ref BLE_ANS_C_EVT_DISCOVERY_COMPLETE.*/ + ble_uuid_t uuid; /**< UUID of the event in case of an alert or notification. */ + union + { + ble_ans_alert_settings_t settings; /**< Setting returned from server on read request. */ + ble_ans_alert_notification_t alert; /**< Alert Notification data sent by the server. */ + uint32_t error_code; /**< Additional status/error code if the event was caused by a stack error or gatt status, e.g. during service discovery. */ + ble_ans_c_service_t service; /**< Info on the discovered Alert Notification Service discovered. This will be filled if the evt_type is @ref BLE_ANS_C_EVT_DISCOVERY_COMPLETE.*/ + } data; +} ble_ans_c_evt_t; + +/**@brief Alert Notification event handler type. */ +typedef void (*ble_ans_c_evt_handler_t) (ble_ans_c_evt_t * p_evt); + +/**@brief Alert Notification structure. This contains various status information for the client. */ +struct ble_ans_c_s +{ + ble_ans_c_evt_handler_t evt_handler; /**< Event handler to be called for handling events in the Alert Notification Client Application. */ + ble_srv_error_handler_t error_handler; /**< Function to be called in case of an error. */ + uint16_t conn_handle; /**< Handle of the current connection (as provided by the BLE stack, is BLE_CONN_HANDLE_INVALID if not in a connection). */ + uint8_t central_handle; /**< Handle for the currently connected central if peer is bonded. */ + uint8_t service_handle; /**< Handle to the service in the database to use for this instance. */ + uint32_t message_buffer_size; /**< Size of message buffer to hold the additional text messages received on notifications. */ + uint8_t * p_message_buffer; /**< Pointer to the buffer to be used for additional text message handling. */ + ble_ans_c_service_t service; /**< Struct to store the different handles and UUIDs related to the service. */ +}; + +/**@brief Alert Notification init structure. This contains all options and data needed for + * initialization of the client.*/ +typedef struct +{ + ble_ans_c_evt_handler_t evt_handler; /**< Event handler to be called for handling events in the Battery Service. */ + ble_srv_error_handler_t error_handler; /**< Function to be called in case of an error. */ + uint32_t message_buffer_size; /**< Size of buffer to handle messages. */ + uint8_t * p_message_buffer; /**< Pointer to buffer for passing messages. */ +} ble_ans_c_init_t; + + +/**@brief Function for handling events from the database discovery module. + * + * @details Call this function when getting a callback event from the DB discovery modue. + * This function will handle an event from the database discovery module, and determine + * if it relates to the discovery of heart rate service at the peer. If so, it will + * call the application's event handler indicating that the heart rate service has been + * discovered at the peer. It also populates the event with the service related + * information before providing it to the application. + * + * @param[in] p_ans Pointer to the Alert Notification client structure instance that will handle + * the discovery. + * @param[in] p_evt Pointer to the event received from the database discovery module. + */ +void ble_ans_c_on_db_disc_evt(ble_ans_c_t * p_ans, ble_db_discovery_evt_t const * p_evt); + + +/**@brief Function for handling the Application's BLE Stack events. + * + * @details Handles all events from the BLE stack of interest to the Alert Notification Client. + * + * @param[in] p_ble_evt Event received from the BLE stack. + * @param[in] p_context Alert Notification Client structure. + */ +void ble_ans_c_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context); + + +/**@brief Function for initializing the Alert Notification Client. + * + * @param[out] p_ans Alert Notification Client structure. This structure will have to be + * supplied by the application. It will be initialized by this function, + * and will later be used to identify this particular client instance. + * @param[in] p_ans_init Information needed to initialize the client. + * + * @return NRF_SUCCESS on successful initialization of client, otherwise an error code. + */ +uint32_t ble_ans_c_init(ble_ans_c_t * p_ans, ble_ans_c_init_t const * p_ans_init); + + +/**@brief Function for writing the to CCCD to enable new alert notifications from the Alert Notification Service. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * + * @return NRF_SUCCESS on successful writing of the CCCD, otherwise an error code. + */ +uint32_t ble_ans_c_enable_notif_new_alert(ble_ans_c_t const * p_ans); + + +/**@brief Function for writing to the CCCD to enable unread alert notifications from the Alert Notification Service. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * + * @return NRF_SUCCESS on successful writing of the CCCD, otherwise an error code. + */ +uint32_t ble_ans_c_enable_notif_unread_alert(ble_ans_c_t const * p_ans); + + +/**@brief Function for writing to the CCCD to disable new alert notifications from the Alert Notification Service. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * + * @return NRF_SUCCESS on successful writing of the CCCD, otherwise an error code. + */ +uint32_t ble_ans_c_disable_notif_new_alert(ble_ans_c_t const * p_ans); + + +/**@brief Function for writing to the CCCD to disable unread alert notifications from the Alert Notification Service. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * + * @return NRF_SUCCESS on successful writing of the CCCD, otherwise an error code. + */ +uint32_t ble_ans_c_disable_notif_unread_alert(ble_ans_c_t const * p_ans); + + +/**@brief Function for writing to the Alert Notification Control Point to specify alert notification behavior in the + * Alert Notification Service on the Central. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be + * supplied by the application. It identifies the particular client + * instance to use. + * @param[in] p_control_point Alert Notification Control Point structure. This structure + * specifies the values to write to the Alert Notification Control + * Point, UUID 0x2A44. + * + * @return NRF_SUCCESS on successful writing of the Control Point, otherwise an error code. + */ +uint32_t ble_ans_c_control_point_write(ble_ans_c_t const * p_ans, + ble_ans_control_point_t const * p_control_point); + + +/**@brief Function for reading the Supported New Alert characteristic value of the service. + * The value describes the alerts supported in the central. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * + * @return NRF_SUCCESS on successful transmission of the read request, otherwise an error code. + */ +uint32_t ble_ans_c_new_alert_read(ble_ans_c_t const * p_ans); + + +/**@brief Function for reading the Supported Unread Alert characteristic value of the service. + * The value describes the alerts supported in the central. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * + * @return NRF_SUCCESS on successful transmission of the read request, otherwise an error code. + */ +uint32_t ble_ans_c_unread_alert_read(ble_ans_c_t const * p_ans); + + +/**@brief Function for requesting the peer to notify the New Alert characteristics immediately. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * @param[in] category The category ID for which the peer should notify the client. + * + * @return NRF_SUCCESS on successful transmission of the read request, otherwise an error code. + */ +uint32_t ble_ans_c_new_alert_notify(ble_ans_c_t const * p_ans, ble_ans_category_id_t category); + + +/**@brief Function for requesting the peer to notify the Unread Alert characteristics immediately. + * + * @param[in] p_ans Alert Notification structure. This structure will have to be supplied by + * the application. It identifies the particular client instance to use. + * @param[in] category The category ID for which the peer should notify the client. + * + * @return NRF_SUCCESS on successful transmission of the read request, otherwise an error code. + */ +uint32_t ble_ans_c_unread_alert_notify(ble_ans_c_t const * p_ans, ble_ans_category_id_t category); + + +/**@brief Function for assigning a handles to a an instance of ans_c. + * + * @details Call this function when a link has been established with a peer to + * associate this link to an instance of the module. This makes it + * possible to handle several link and associate each link to a particular + * instance of the ans_c module. The connection handle and attribute handles will be + * provided from the discovery event @ref BLE_ANS_C_EVT_DISCOVERY_COMPLETE. + * + * @param[in] p_ans Pointer to the Alert Notification client structure instance to + * associate with the handles. + * @param[in] conn_handle Connection handle to associated with the given Alert Notification Client + * Instance. + * @param[in] p_peer_handles Attribute handles on the ANS server that you want this ANS client to + * interact with. + * + */ +uint32_t ble_ans_c_handles_assign(ble_ans_c_t * p_ans, + uint16_t const conn_handle, + ble_ans_c_service_t const * p_peer_handles); + + + + +#ifdef __cplusplus +} +#endif + +#endif // BLE_ANS_C_H__ + +/** @} */ + |