BlueNRGGattClient.cpp

00001 /* mbed Microcontroller Library
00002 * Copyright (c) 2006-2013 ARM Limited
00003 *
00004 * Licensed under the Apache License, Version 2.0 (the "License");
00005 * you may not use this file except in compliance with the License.
00006 * You may obtain a copy of the License at
00007 *
00008 *     http://www.apache.org/licenses/LICENSE-2.0
00009 *
00010 * Unless required by applicable law or agreed to in writing, software
00011 * distributed under the License is distributed on an "AS IS" BASIS,
00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 * See the License for the specific language governing permissions and
00014 * limitations under the License.
00015 */
00016 /**
00017   ******************************************************************************
00018   * @file    BlueNRGGattServer.cpp
00019   * @author  STMicroelectronics
00020   * @brief   Implementation of BlueNRG BLE_API GattServer Class
00021   ******************************************************************************
00022   * @copy
00023   *
00024   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
00025   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
00026   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
00027   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
00028   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
00029   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
00030   *
00031   * <h2><center>&copy; COPYRIGHT 2013 STMicroelectronics</center></h2>
00032   */
00033 
00034 /** @defgroup BlueNRGGATTClient
00035  *  @brief BlueNRG BLE_API GattClient Adaptation
00036  *  @{
00037  */
00038 
00039 #include "BlueNRGGattClient.h"
00040 #ifdef YOTTA_CFG_MBED_OS
00041     #include "mbed-drivers/mbed.h"
00042 #else
00043     #include "mbed.h"
00044 #endif 
00045 #include "BlueNRGGap.h"
00046 #include "ble_utils.h"
00047 #include "ble_debug.h"
00048 
00049 #include <new>
00050 #include <assert.h>
00051 
00052 ble_error_t BlueNRGGattClient::createGattConnectionClient(Gap::Handle_t connectionHandle)
00053 {
00054   if(MAX_ACTIVE_CONNECTIONS <= _numConnections) {
00055     return BLE_ERROR_OPERATION_NOT_PERMITTED;
00056   }
00057 
00058   for(uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; i++) {
00059 
00060     if(_connectionPool[i] == NULL) {
00061       BlueNRGGattConnectionClient *gattConnectionClient = new(std::nothrow) BlueNRGGattConnectionClient(this, connectionHandle);
00062 
00063       if (gattConnectionClient == NULL) {
00064         return BLE_ERROR_NO_MEM;
00065       }
00066 
00067       _connectionPool[i] = gattConnectionClient;
00068       _connectionPool[i]->onServiceDiscoveryTermination(terminationCallback);
00069       _numConnections++;
00070 
00071       PRINTF("createGattConnectionClient: _connectionPool index=%d\r\n", i);
00072       PRINTF("createGattConnectionClient: succesfully added new gattConnectionClient (_numConnections=%d)\r\n", _numConnections);
00073       break;
00074     }
00075   }
00076 
00077   return BLE_ERROR_NONE;
00078 }
00079 
00080 ble_error_t BlueNRGGattClient::removeGattConnectionClient(Gap::Handle_t connectionHandle, uint8_t reason)
00081 {
00082 
00083   PRINTF("removeGattConnectionClient: connectionHandle=%d reason=0x%x\r\n", connectionHandle, reason);
00084 
00085   for (uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; i++) {
00086     PRINTF("removeGattConnectionClient: _connectionPool[%d]->_connectionHandle=%d\r\n", i, _connectionPool[i]->_connectionHandle);
00087 
00088     if(_connectionPool[i]->_connectionHandle == connectionHandle) {
00089       PRINTF("removeGattConnectionClient: Found gattConnectionClient\r\n");
00090       delete _connectionPool[i];
00091       _connectionPool[i] = NULL;
00092 
00093       _numConnections--;
00094       PRINTF("removeGattConnectionClient: succesfully removed gattConnectionClient (_numConnections=%d)\r\n", _numConnections);
00095 
00096       break;
00097 
00098     } else {
00099       return BLE_ERROR_INTERNAL_STACK_FAILURE;
00100     }
00101   }
00102 
00103   return BLE_ERROR_NONE;
00104 }
00105 
00106 BlueNRGGattConnectionClient * BlueNRGGattClient::getGattConnectionClient(Gap::Handle_t connectionHandle) {
00107   PRINTF("getGattConnectionClient\r\n");
00108 
00109   for (uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; i++) {
00110     PRINTF("getGattConnectionClient: _connectionPool[%d]->_connectionHandle=%d\r\n", i, _connectionPool[i]->_connectionHandle);
00111 
00112     if(_connectionPool[i]->_connectionHandle == connectionHandle) {
00113       PRINTF("getGattConnectionClient: Found gattConnectionClient\r\n");
00114       return _connectionPool[i];
00115     }
00116   }
00117 
00118   return NULL;
00119 }
00120 
00121 void BlueNRGGattClient::gattProcedureCompleteCB(Gap::Handle_t connectionHandle, uint8_t error_code) {
00122 
00123   if(error_code != BLE_STATUS_SUCCESS) {
00124     return;
00125   }
00126 
00127   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00128 
00129   assert(gattConnectionClient != NULL);
00130 
00131   gattConnectionClient->gattProcedureCompleteCB(error_code);
00132 }
00133 
00134 void BlueNRGGattClient::primaryServicesCB(Gap::Handle_t connectionHandle,
00135                                           uint8_t event_data_length,
00136                                           uint8_t attribute_data_length,
00137                                           uint8_t *attribute_data_list) {
00138 
00139   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00140 
00141   assert(gattConnectionClient != NULL);
00142 
00143   gattConnectionClient->primaryServicesCB(event_data_length,
00144                                           attribute_data_length,
00145                                           attribute_data_list);
00146 }
00147     
00148 void BlueNRGGattClient::primaryServiceCB(Gap::Handle_t connectionHandle,
00149                                          uint8_t event_data_length,
00150                                          uint8_t *handles_info_list) {
00151 
00152   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00153 
00154   assert(gattConnectionClient != NULL);
00155 
00156   gattConnectionClient->primaryServiceCB(event_data_length,
00157                                          handles_info_list);
00158 }
00159     
00160 ble_error_t BlueNRGGattClient::findServiceChars(Gap::Handle_t connectionHandle) {
00161 
00162   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00163 
00164   if(gattConnectionClient != NULL) {
00165     return gattConnectionClient->findServiceChars();
00166   } else {
00167     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00168   }
00169 }
00170     
00171 void BlueNRGGattClient::serviceCharsCB(Gap::Handle_t connectionHandle,
00172                                        uint8_t event_data_length,
00173                                        uint8_t handle_value_pair_length,
00174                                        uint8_t *handle_value_pair) {
00175 
00176   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00177 
00178   assert(gattConnectionClient != NULL);
00179 
00180   gattConnectionClient->serviceCharsCB(event_data_length,
00181                                        handle_value_pair_length,
00182                                        handle_value_pair);
00183 }
00184     
00185 void BlueNRGGattClient::serviceCharByUUIDCB(Gap::Handle_t connectionHandle,
00186                                             uint8_t event_data_length,
00187                                             uint16_t attr_handle,
00188                                             uint8_t *attr_value) {
00189 
00190   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00191 
00192   assert(gattConnectionClient != NULL);
00193 
00194   gattConnectionClient->serviceCharByUUIDCB(event_data_length,
00195                                             attr_handle,
00196                                             attr_value);
00197 }
00198 
00199 void BlueNRGGattClient::discAllCharacDescCB(Gap::Handle_t connHandle,
00200                                             uint8_t event_data_length,
00201                                             uint8_t format,
00202                                             uint8_t *handle_uuid_pair) {
00203 
00204   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connHandle);
00205 
00206   assert(gattConnectionClient != NULL);
00207 
00208   gattConnectionClient->discAllCharacDescCB(event_data_length,
00209                                             format,
00210                                             handle_uuid_pair);
00211 }
00212 
00213 void BlueNRGGattClient::charReadCB(Gap::Handle_t connHandle,
00214                                    uint8_t event_data_length,
00215                                    uint8_t* attribute_value) {
00216 
00217   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connHandle);
00218 
00219   assert(gattConnectionClient != NULL);
00220 
00221   gattConnectionClient->charReadCB(event_data_length,
00222                                    attribute_value);
00223 }
00224 
00225 void BlueNRGGattClient::charWritePrepareCB(Gap::Handle_t connHandle,
00226                                            uint8_t event_data_length,
00227                                            uint16_t attribute_handle,
00228                                            uint16_t offset,
00229                                            uint8_t *part_attr_value) {
00230 
00231   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connHandle);
00232 
00233   assert(gattConnectionClient != NULL);
00234 
00235   gattConnectionClient->charWritePrepareCB(event_data_length,
00236                                            attribute_handle,
00237                                            offset,
00238                                            part_attr_value);
00239 }
00240     
00241 void BlueNRGGattClient::charWriteExecCB(Gap::Handle_t connHandle,
00242                                         uint8_t event_data_length) {
00243 
00244   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connHandle);
00245 
00246   assert(gattConnectionClient != NULL);
00247 
00248   gattConnectionClient->charWriteExecCB(event_data_length);
00249 }
00250 
00251 ble_error_t BlueNRGGattClient::launchServiceDiscovery(Gap::Handle_t                               connectionHandle,
00252                                                       ServiceDiscovery::ServiceCallback_t         sc,
00253                                                       ServiceDiscovery::CharacteristicCallback_t  cc,
00254                                                       const UUID                                 &matchingServiceUUID,
00255                                                       const UUID                                 &matchingCharacteristicUUIDIn)
00256 {
00257   PRINTF("BlueNRGGattClient launchServiceDiscovery\n\r");
00258 
00259   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00260 
00261   if(gattConnectionClient != NULL) {
00262     return gattConnectionClient->launchServiceDiscovery(sc, cc, matchingServiceUUID, matchingCharacteristicUUIDIn);
00263   } else {
00264     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00265   }
00266 }
00267 
00268 ble_error_t BlueNRGGattClient::discoverServices(Gap::Handle_t                        connectionHandle,
00269                                                 ServiceDiscovery::ServiceCallback_t  callback,
00270                                                 const UUID                          &matchingServiceUUID)
00271 {
00272   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00273 
00274   if(gattConnectionClient != NULL) {
00275 
00276     return gattConnectionClient->discoverServices(callback, matchingServiceUUID);
00277 
00278   } else {
00279     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00280   }
00281 }
00282 
00283 ble_error_t BlueNRGGattClient::discoverServices(Gap::Handle_t                        connectionHandle,
00284                                                 ServiceDiscovery::ServiceCallback_t  callback,
00285                                                 GattAttribute::Handle_t              startHandle,
00286                                                 GattAttribute::Handle_t              endHandle)
00287 {
00288   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(connectionHandle);
00289 
00290   if(gattConnectionClient != NULL) {
00291 
00292     return gattConnectionClient->discoverServices(callback, startHandle, endHandle);
00293 
00294   } else {
00295     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00296   }
00297 }
00298 
00299 bool BlueNRGGattClient::isServiceDiscoveryActive(void) const
00300 {
00301   bool isSDActive = false;
00302 
00303   for (uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; i++) {
00304     if (_connectionPool[i]) { 
00305       isSDActive |= _connectionPool[i]->isServiceDiscoveryActive();
00306     }
00307   }
00308 
00309   return isSDActive;
00310 }
00311 
00312 void BlueNRGGattClient::terminateServiceDiscovery(void)
00313 {
00314   for (uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; i++) {
00315     if (_connectionPool[i]) { 
00316       _connectionPool[i]->terminateServiceDiscovery();
00317     }
00318   }
00319 }
00320 
00321 void BlueNRGGattClient::onServiceDiscoveryTermination(ServiceDiscovery::TerminationCallback_t callback) {
00322   terminationCallback = callback;
00323   for (uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; ++i) {
00324     if (_connectionPool[i]) { 
00325       _connectionPool[i]->onServiceDiscoveryTermination(callback);
00326     }
00327   }
00328 }
00329 
00330 ble_error_t BlueNRGGattClient::read(Gap::Handle_t connHandle, GattAttribute::Handle_t attributeHandle, uint16_t offset) const
00331 {
00332   BlueNRGGattConnectionClient *gattConnectionClient = const_cast<BlueNRGGattClient*>(this)->getGattConnectionClient(connHandle);
00333 
00334   if(gattConnectionClient != NULL) {
00335 
00336     return gattConnectionClient->read(attributeHandle, offset);
00337 
00338   } else {
00339     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00340   }
00341 }
00342 
00343 ble_error_t BlueNRGGattClient::write(GattClient::WriteOp_t    cmd,
00344                                      Gap::Handle_t            connHandle,
00345                                      GattAttribute::Handle_t  attributeHandle,
00346                                      size_t                   length,
00347                                      const uint8_t           *value) const
00348 {
00349   BlueNRGGattConnectionClient *gattConnectionClient = const_cast<BlueNRGGattClient*>(this)->getGattConnectionClient(connHandle);
00350 
00351   if(gattConnectionClient != NULL) {
00352 
00353     return gattConnectionClient->write(cmd, attributeHandle, length, value);
00354 
00355   } else {
00356     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00357   }
00358 }
00359 
00360 ble_error_t BlueNRGGattClient::discoverCharacteristicDescriptors(
00361         const DiscoveredCharacteristic& characteristic,
00362         const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback,
00363         const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback)
00364 {
00365   BlueNRGGattConnectionClient *gattConnectionClient = getGattConnectionClient(characteristic.getConnectionHandle());
00366 
00367   if(gattConnectionClient != NULL) {
00368 
00369     return gattConnectionClient->discoverCharacteristicDescriptors(characteristic, discoveryCallback, terminationCallback);
00370 
00371   } else {
00372     return BLE_ERROR_INTERNAL_STACK_FAILURE;
00373   }
00374 }
00375 
00376 /**************************************************************************/
00377 /*!
00378     @brief  Clear BlueNRGGattClient's state.
00379 
00380     @returns    ble_error_t
00381 
00382     @retval     BLE_ERROR_NONE
00383                 Everything executed properly
00384 */
00385 /**************************************************************************/
00386 ble_error_t BlueNRGGattClient::reset(void)
00387 {
00388   PRINTF("BlueNRGGattClient::reset\n");
00389 
00390   for (uint8_t i = 0; i < MAX_ACTIVE_CONNECTIONS; i++) {
00391     if(_connectionPool[i] != NULL) {
00392       _connectionPool[i]->reset();
00393 
00394       delete _connectionPool[i];
00395       _connectionPool[i] = NULL;
00396 
00397       _numConnections--;
00398     }
00399   }
00400 
00401   return BLE_ERROR_NONE;
00402 }
00403