static void ble_evt_handler()

in Firmware/Platform_NordicSDK/EPXPlatform_BLE.c [272:435]

• 134 lines of code
• 28 McCabe index (conditional complexity)

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
	uint32_t err_code;
	ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt;

	// DEBUGLOGLN("ble_evt_handler %d", p_ble_evt->header.evt_id);
	switch (p_ble_evt->header.evt_id)
	{
	case BLE_GAP_EVT_CONNECTED:
		NRF_LOG_INFO("BLE Connected %d ms", p_ble_evt->evt.gap_evt.params.connected.conn_params.min_conn_interval * 1.25);
		g_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
		(*g_pfnConnectionStateChanged)(g_hostInstance, true);
		break;

	case BLE_GAP_EVT_DISCONNECTED:
		NRF_LOG_INFO("BLE Disconnected");
		g_conn_handle = BLE_CONN_HANDLE_INVALID;
		(*g_pfnConnectionStateChanged)(g_hostInstance, false);
		break;

	case BLE_GAP_EVT_ADV_REPORT:
		if (g_ppBeaconActivationEntries != NULL)
		{
			BEACONACTIVATIONITEM *pItem = *g_ppBeaconActivationEntries;
				
			while (pItem != NULL)
			{
				// If the MAC address hasn't been seend and cached yet, try to resolve by name
				if(memcmp(pItem->beaconHostAddr, g_emptyBeaconHostAddr, sizeof(g_emptyBeaconHostAddr)) == 0)
				{
					char szScanDeviceName[32];
					uint16_t offset = 0;
					uint16_t nameLen = ble_advdata_search(p_gap_evt->params.adv_report.data.p_data, p_gap_evt->params.adv_report.data.len, &offset, BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
						
					if (nameLen > 0)
					{							
						memcpy(szScanDeviceName, &p_gap_evt->params.adv_report.data.p_data[offset], nameLen);
						szScanDeviceName[nameLen] = 0x00;							
						if (stricmp(pItem->szBeaconHostName, szScanDeviceName) == 0)						
							memcpy(pItem->beaconHostAddr, p_gap_evt->params.adv_report.peer_addr.addr, sizeof(pItem->beaconHostAddr));
					}
				}
			
				// See if MAC addresses match
				if(memcmp(p_gap_evt->params.adv_report.peer_addr.addr, pItem->beaconHostAddr, sizeof(pItem->beaconHostAddr)) == 0)			
				{					
					uint8_t *mfd_data = ble_advdata_parse(p_gap_evt->params.adv_report.data.p_data, p_gap_evt->params.adv_report.data.len, BLE_GAP_AD_TYPE_MANUFACTURER_SPECIFIC_DATA);
					if (mfd_data != NULL)
					{
						uint8_t advBeaconData = (uint8_t) *(mfd_data + sizeof(uint16_t));

						g_lastBeaconReceived = millis();
						if (g_beaconData != advBeaconData)
						{
							NRF_LOG_INFO("MANUDATA 0x%02x", advBeaconData);
							g_beaconData = advBeaconData;
							if (g_pfnBLEBeaconReceived != NULL)
								(*g_pfnBLEBeaconReceived)(g_hostInstance, pItem->szBeaconHostName, g_beaconData);
						}
					}					
				}					
				pItem = pItem->pNext;
			}
		}
		break;

#ifndef S140
	case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
		{
			NRF_LOG_DEBUG("PHY update request.");
			ble_gap_phys_t const phys =
			{
				.rx_phys = BLE_GAP_PHY_AUTO,
				.tx_phys = BLE_GAP_PHY_AUTO,
			};
			err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
			APP_ERROR_CHECK(err_code);
		} break;
#endif

	case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
		// Pairing not supported
		err_code = sd_ble_gap_sec_params_reply(g_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
		APP_ERROR_CHECK(err_code);
		break;
		
#if !defined (S112)
	case BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST:
		{
			ble_gap_data_length_params_t dl_params;

			// Clearing the struct will effectivly set members to @ref BLE_GAP_DATA_LENGTH_AUTO
			memset(&dl_params, 0, sizeof(ble_gap_data_length_params_t));
			err_code = sd_ble_gap_data_length_update(p_ble_evt->evt.gap_evt.conn_handle, &dl_params, NULL);
			APP_ERROR_CHECK(err_code);
		} break;
#endif //!defined (S112)
		
	case BLE_GATTS_EVT_SYS_ATTR_MISSING:
		// No system attributes have been stored.
		err_code = sd_ble_gatts_sys_attr_set(g_conn_handle, NULL, 0, 0);
		APP_ERROR_CHECK(err_code);
		break;

	case BLE_GATTC_EVT_TIMEOUT:
		// Disconnect on GATT Client timeout event.
		err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
			BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
		APP_ERROR_CHECK(err_code);
		break;

	case BLE_GATTS_EVT_TIMEOUT:
		// Disconnect on GATT Server timeout event.
		err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
			BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
		APP_ERROR_CHECK(err_code);
		break;

	case BLE_GATTS_EVT_HVN_TX_COMPLETE:
		g_ble_gatts_hvntx_complete = true;
		break;
			
	case BLE_EVT_USER_MEM_REQUEST:
		err_code = sd_ble_user_mem_reply(p_ble_evt->evt.gattc_evt.conn_handle, NULL);
		APP_ERROR_CHECK(err_code);
		break;

	case BLE_GATTS_EVT_WRITE:
		break;
		
	case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
		{
			ble_gatts_evt_rw_authorize_request_t  req;
			ble_gatts_rw_authorize_reply_params_t auth_reply;

			req = p_ble_evt->evt.gatts_evt.params.authorize_request;

			if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID)
			{
				if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ)     ||
				    (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) ||
				    (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
				{
					if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
					{
						auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
					}
					else
					{
						auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
					}
					auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
					err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
						&auth_reply);
					APP_ERROR_CHECK(err_code);
				}
			}
		} break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST

		default :
		    // No implementation needed.
		    break;
	}
}