/**@brief Authorize WRITE request event handler.
*
* @details Handles WRITE events from the BLE stack.
*
* @param[in] p_sc_ctrlpt SC Ctrlpt structure.
* @param[in] p_gatts_evt GATTS Event received from the BLE stack.
*
*/
static void on_rw_authorize_request(ble_agsensor_t * p_agsensor, ble_gatts_evt_t * p_gatts_evt)
{
ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request;
if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
if ( (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_PREP_WRITE_REQ)
&& (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
&& (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)
)
{
if (p_auth_req->request.write.handle == p_agsensor->configuration_handles.value_handle)
{
on_write(p_agsensor, &p_auth_req->request.write);
}
if (p_auth_req->request.write.handle == p_agsensor->data_handles.value_handle)
{
on_write(p_agsensor, &p_auth_req->request.write);
}
}
}
}
/**@brief Authorize WRITE request event handler.
*
* @details Handles WRITE events from the BLE stack.
*
* @param[in] p_sc_ctrlpt SC Ctrlpt structure.
* @param[in] p_gatts_evt GATTS Event received from the BLE stack.
*
*/
static void on_rw_authorize_request(ble_dfu__nordic__t * p_dfu__nordic_, ble_gatts_evt_t * p_gatts_evt)
{
ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request;
if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
if ( (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_PREP_WRITE_REQ)
&& (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
&& (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)
)
{
if (p_auth_req->request.write.handle == p_dfu__nordic_->dfu_packet_handles.value_handle)
{
on_write(p_dfu__nordic_, &p_auth_req->request.write);
}
if (p_auth_req->request.write.handle == p_dfu__nordic_->dfu_control_point_handles.value_handle)
{
on_write(p_dfu__nordic_, &p_auth_req->request.write);
}
}
}
}
void eventLoop( HANDLE hIocp )
{
DWORD bytesTransferred = 0;
SP_TestClient * client = NULL;
SP_TestEvent * event = NULL;
BOOL isSuccess = GetQueuedCompletionStatus( hIocp, &bytesTransferred,
(DWORD*)&client, (OVERLAPPED**)&event, 100 );
DWORD lastError = WSAGetLastError();
if( ! isSuccess ) {
if( NULL != client ) {
gStat.mGQCSFail++;
close_client( client );
}
return;
}
if( SP_TestEvent::eEventRecv == event->mType ) {
on_read( client, event );
return;
}
if( SP_TestEvent::eEventSend == event->mType ) {
on_write( client, event );
return;
}
}
void nrf_ble_cgms_on_ble_evt(nrf_ble_cgms_t * p_cgms, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
p_cgms->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
p_cgms->cgms_com_state = STATE_NO_COMM;
break;
case BLE_GAP_EVT_DISCONNECTED:
p_cgms->conn_handle = BLE_CONN_HANDLE_INVALID;
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_cgms, p_ble_evt);
break;
case BLE_EVT_TX_COMPLETE:
on_tx_complete(p_cgms, p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_request(p_cgms, &p_ble_evt->evt.gatts_evt);
break;
case BLE_GATTS_EVT_HVC:
on_hvc(p_cgms, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
void ble_bas_on_ble_evt(ble_bas_t * p_bas, ble_evt_t * p_ble_evt)
{
if (p_bas == NULL || p_ble_evt == NULL)
{
return;
}
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_bas, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_bas, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_bas, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
void ble_dfu_on_ble_evt(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt)
{
VERIFY_PARAM_NOT_NULL_VOID(p_dfu);
VERIFY_PARAM_NOT_NULL_VOID(p_ble_evt);
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_dfu, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_dfu, p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_req(p_dfu, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_dfu, p_ble_evt);
break;
default:
// no implementation
break;
}
}
void ble_hrs_on_ble_evt(uint16_t * p_peripheral_conn_handle, ble_hrs_t * p_hrs, ble_evt_t * p_ble_evt)
{
uint16_t peripheral_conn_handle = * p_peripheral_conn_handle; //todo;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
if(p_ble_evt->evt.gap_evt.params.connected.role == BLE_GAP_ROLE_PERIPH) //If this side is BLE_GAP_ROLE_PERIPH then BLE_GAP_EVT_CONNECTED comes from peer central
{
on_connect(p_hrs, p_ble_evt);
}
break;
case BLE_GAP_EVT_DISCONNECTED:
if(p_ble_evt->evt.gap_evt.conn_handle == peripheral_conn_handle)
{
on_disconnect(p_hrs, p_ble_evt);
}
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_hrs, p_ble_evt);
break;
case BLE_GATTC_EVT_HVX:
on_peer_peripheral_hvx(p_hrs, p_ble_evt);
default:
// No implementation needed.
break;
}
}
void ble_conn_params_on_ble_evt(ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_ble_evt);
break;
case BLE_GAP_EVT_CONN_PARAM_UPDATE:
on_conn_params_update(p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
int tcp_data_handler::send( packet *p,int delay_flag)
{
if(m_id.fd < 0 || m_connect_status != STATUS_CONNECTED ) return -1 ;
int size = p->encode_size() ;
if(size < 1 ) return -1 ;
if(m_sbuf.space_size() < size && m_sbuf.resize(m_sbuf.capacity() + size )!=0)
{
return -1 ;
}
size = p->encode(m_sbuf.space(),m_sbuf.space_size()) ;
if ( size < 1 ) return -1 ;
m_sbuf.push_data(size) ;
if(m_reactor && (m_write_flag == 0) )
{
if(m_reactor->mod_handler(m_id.fd,this,
base_reactor::EVENT_READ | base_reactor::EVENT_WRITE)==0 )
{
m_write_flag = 1;
}
}
if(delay_flag == 0) on_write(m_id.fd) ;
return 0 ;
}
void ble_hts_on_ble_evt(ble_hts_t * p_hts, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_hts, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_hts, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_hts, p_ble_evt);
break;
case BLE_GATTS_EVT_HVC:
on_hvc(p_hts, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
void ble_dfu_on_ble_evt(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt)
{
if ((p_dfu == NULL) || (p_ble_evt == NULL))
{
return;
}
if (p_dfu->evt_handler != NULL)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_dfu, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_dfu, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_dfu, p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_req(p_dfu, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
}
int worker_epoll_start(int epoll_fd, unsigned int max_events, int channel_fd)
{
int nfds;
struct epoll_event events[max_events];
nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, EPOLL_DELAY);
if(nfds == -1) {
perror("epoll_wait");
return L_HTTP_FAIL;
}
for(int n = 0; n < nfds; ++n) {
if (events[n].data.fd == channel_fd) {
//if((epoll_fd, listen_sock) == L_HTTP_FAIL)
// continue;
if(on_channel(epoll_fd, channel_fd) == L_HTTP_FAIL)
continue;
}
else if(events[n].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
{
if(on_read(epoll_fd, events[n].data.fd) == L_HTTP_FAIL) {
on_close(epoll_fd, events[n].data.fd);
continue;
}
}
else if(events[n].events & EPOLLOUT) // 如果有数据发送
{
on_write(epoll_fd, events[n].data.fd);
on_close(epoll_fd, events[n].data.fd);
}
}
return L_HTTP_SUCCESS;
}
void ble_lc_on_ble_event(ble_lc_t * p_lc, ble_evt_t * p_ble_evt)
{
if ((p_lc == NULL) || (p_ble_evt == NULL))
{
return;
}
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_lc, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_lc, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_lc, p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_read(p_lc, p_ble_evt);
break;
default:
// Nothing needed
break;
}
}
void ble_iqo_on_ble_evt(ble_iqo_t * p_iqo, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_iqo, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_iqo, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_iqo, p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_request(p_iqo, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
void ble_nus_on_ble_evt(ble_nus_t * p_nus, ble_evt_t * p_ble_evt)
{
if ((p_nus == NULL) || (p_ble_evt == NULL))
{
return;
}
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_nus, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_nus, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE: // host에서 data를 write 할때 들어옴.
on_write(p_nus, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
/**
* @brief notify incoming io event
*/
void http_event::on_event() {
if (this->get_state() == "read_head") {
on_read_head();
} else if (this->get_state() == "read_body") {
on_read_body();
} else {
on_write();
}
}
int app::handle_write(app_connection * n){
n->post_send();
if(!n->get_wait_to_send_data_len()){
return on_write(n);
}
else{
return 0;
}
}
void ble_ias_on_ble_evt(ble_ias_t * p_ias, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GATTS_EVT_WRITE:
on_write(p_ias, p_ble_evt);
break;
default:
break;
}
}
void ble_ias_on_ble_evt(ble_ias_t * p_ias, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GATTS_EVT_WRITE:
on_write(p_ias, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
m_conn_handle = BLE_CONN_HANDLE_INVALID;
application_timers_stop();
// Go to system-off mode
err_code = sd_power_system_off();
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle,
NULL,
0,
BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS | BLE_GATTS_SYS_ATTR_FLAG_USR_SRVCS);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING)
{
// Go to system-off mode (this function will not return; wakeup will cause a reset).
err_code = sd_power_system_off();
APP_ERROR_CHECK(err_code);
}
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Authorize WRITE request event handler.
*
* @details Handles WRITE events from the BLE stack.
*
* @param[in] p_sc_ctrlpt SC Ctrlpt structure.
* @param[in] p_gatts_evt GATTS Event received from the BLE stack.
*
*/
static void on_rw_authorize_request(ble_display_service_t * p_display_service, ble_gatts_evt_t * p_gatts_evt)
{
ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request;
if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
if ((p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_PREP_WRITE_REQ)
&& (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
&& (p_gatts_evt->params.authorize_request.request.write.op
!= BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
{
if (p_auth_req->request.write.handle == p_display_service->record_number_handles.value_handle)
{
on_write(p_display_service, &p_auth_req->request.write);
}
}
}
}
/*!
* \brief Write to a File handle.
*
* Example usage:
*
* \code{.cpp}
* size_t n;
*
* if (file.write(file, buf, sizeof(buf), &bytesWritten)
* != FileStatus::OK) {
* printf("Failed to write file: %s\n", file.error_string().c_str());
* }
* \endcode
*
* \param[in] buf Buffer to write from
* \param[in] size Buffer size
* \param[out] bytes_written Output number of bytes that were written. This
* parameter cannot be NULL.
*
* \return
* * #FileStatus::OK if some bytes were written
* * #FileStatus::RETRY if the same operation should be reattempted
* * #FileStatus::UNSUPPORTED if the handle source does not support writing
* * \<= #FileStatus::WARN if an error occurs
*/
FileStatus File::write(const void *buf, size_t size, size_t *bytes_written)
{
GET_PIMPL_OR_RETURN(FileStatus::FATAL);
ENSURE_STATE(FileState::OPENED);
auto ret = FileStatus::UNSUPPORTED;
if (!bytes_written) {
set_error(FileError::PROGRAMMER_ERROR,
"%s: bytes_written is NULL", __func__);
ret = FileStatus::FATAL;
} else {
ret = on_write(buf, size, bytes_written);
}
if (ret <= FileStatus::FATAL) {
priv->state = FileState::FATAL;
}
return ret;
}
void ble_bas_on_ble_evt(ble_bas_t * p_bas, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_bas, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_bas, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_bas, p_ble_evt);
break;
default:
break;
}
}
/**@brief Function for handling BLE events.
*
* @param[in] p_dfu__nordic_ DFU (Nordic) Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
void ble_dfu__nordic__on_ble_evt(ble_dfu__nordic__t * p_dfu__nordic_, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_dfu__nordic_, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_dfu__nordic_, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_dfu__nordic_, &p_ble_evt->evt.gatts_evt.params.write);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_request(p_dfu__nordic_, &p_ble_evt->evt.gatts_evt);
break;
default:
//No implementation needed.
break;
}
}
void ble_doorlock_on_ble_evt(ble_evt_t * p_ble_evt)
{
ble_doorlock_t *p_doorlock = &m_doorlock;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_doorlock, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_doorlock, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_doorlock, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
void ble_nus_on_ble_evt(ble_nus_t * p_nus, ble_evt_t * p_ble_evt)
{
if ((p_nus == NULL) || (p_ble_evt == NULL))
{
return;
}
#if ((DEBUG_UART_EN) && (ENABLE_BLE_DEBUG))
//DbgPrintf("id=%x\r\n",p_ble_evt->header.evt_id);
#endif
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_nus, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_nus, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
#if ((DEBUG_UART_EN) && (ENABLE_BLE_DEBUG))
//DbgPrintf("common_evt.conn_handle=%x\r\n,gap_evt.conn_handle=%x\r\n,l2cap_evt.conn_handle=%x\r\n,gattc_evt.conn_handle=%x\r\n,gatts_evt.conn_handle=%x\r\n",
// p_ble_evt->evt.common_evt.conn_handle,
// p_ble_evt->evt.gap_evt.conn_handle,
// p_ble_evt->evt.l2cap_evt.conn_handle,
// p_ble_evt->evt.gattc_evt.conn_handle,
// p_ble_evt->evt.gatts_evt.conn_handle
// );
#endif
on_write(p_nus, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
/*
* Function for handling the BLE events.
*
* param[in] p_temp Temp Service structure.
* param[in] p_ble_evt Event received from the BLE stack.
*/
void ble_temp_on_ble_evt(ble_temp_t * p_temp, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id) {
case BLE_GAP_EVT_CONNECTED:
PUTS("evt_id: CONNECTED");
on_connect(p_temp, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_temp, p_ble_evt);
PUTS("Stop temp timer");
APP_ERROR_CHECK(app_timer_stop(m_temperature_timer_id));
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_temp, p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
break;
case BLE_GATTS_EVT_HVC:
break;
case BLE_GATTS_EVT_SC_CONFIRM:
break;
case BLE_GATTS_EVT_TIMEOUT:
break;
default:
break;
}
}
void ble_luxsync_on_ble_evt(ble_luxsync_t * p_luxsync, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_luxsync, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_luxsync, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_luxsync, p_ble_evt);
break;
case BLE_EVT_TX_COMPLETE:
sendDataFlag = 1;
if(flag_send_data)
{
send_data_stream_ble(p_luxsync, fetchMoreData, 0);
if ( fetchMoreData )
fetchMoreData = 0;
}
//heart_rate_meas_send();
break;
default:
// No implementation needed.
break;
}
}
void ble_cscs_on_ble_evt(ble_cscs_t * p_cscs, ble_evt_t * p_ble_evt)
{
ble_sc_ctrlpt_on_ble_evt(&(p_cscs->ctrl_pt), p_ble_evt);
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_cscs, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_cscs, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_cscs, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
void ble_dp_on_ble_evt(ble_dp_t * p_dp, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id) //See ble_gap.h line 409
{
/**< Connection established. */
case BLE_GAP_EVT_CONNECTED:
on_connect(p_dp, p_ble_evt);
break;
/**< Disconnected from peer. */
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_dp, p_ble_evt);
break;
/**< Write operation performed. */
case BLE_GATTS_EVT_WRITE:
on_write(p_dp, p_ble_evt);
break;
default:
break;
}
}
