Kenji Arai / mbed-os_TYBLE16

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   TYBLE16_simple_data_logger TYBLE16_MP3_Air

features/FEATURE_BLE/ble/BLE.h@1:9db0e321a9f4, 2019-12-31 (annotated)

Committer:
kenjiArai
Date:
Tue Dec 31 06:02:27 2019 +0000
Revision:
1:9db0e321a9f4
Parent:
0:5b88d5760320 
updated based on mbed-os5.15.0

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kenjiArai 0:5b88d5760320 1 /* mbed Microcontroller Library
kenjiArai 0:5b88d5760320 2 * Copyright (c) 2006-2013 ARM Limited
kenjiArai 0:5b88d5760320 3 *
kenjiArai 0:5b88d5760320 4 * Licensed under the Apache License, Version 2.0 (the "License");
kenjiArai 0:5b88d5760320 5 * you may not use this file except in compliance with the License.
kenjiArai 0:5b88d5760320 6 * You may obtain a copy of the License at
kenjiArai 0:5b88d5760320 7 *
kenjiArai 0:5b88d5760320 8 * http://www.apache.org/licenses/LICENSE-2.0
kenjiArai 0:5b88d5760320 9 *
kenjiArai 0:5b88d5760320 10 * Unless required by applicable law or agreed to in writing, software
kenjiArai 0:5b88d5760320 11 * distributed under the License is distributed on an "AS IS" BASIS,
kenjiArai 0:5b88d5760320 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
kenjiArai 0:5b88d5760320 13 * See the License for the specific language governing permissions and
kenjiArai 0:5b88d5760320 14 * limitations under the License.
kenjiArai 0:5b88d5760320 15 */
kenjiArai 0:5b88d5760320 16
kenjiArai 0:5b88d5760320 17 #ifndef MBED_BLE_H__
kenjiArai 0:5b88d5760320 18 #define MBED_BLE_H__
kenjiArai 0:5b88d5760320 19
kenjiArai 0:5b88d5760320 20 #include "BLERoles.h"
kenjiArai 0:5b88d5760320 21
kenjiArai 0:5b88d5760320 22 #include "blecommon.h"
kenjiArai 0:5b88d5760320 23 #include "ble/Gap.h"
kenjiArai 0:5b88d5760320 24 #include "ble/GattServer.h"
kenjiArai 0:5b88d5760320 25 #include "ble/GattClient.h"
kenjiArai 0:5b88d5760320 26 #include "ble/SecurityManager.h"
kenjiArai 0:5b88d5760320 27
kenjiArai 0:5b88d5760320 28 #include "ble/FunctionPointerWithContext.h"
kenjiArai 0:5b88d5760320 29
kenjiArai 0:5b88d5760320 30 #ifdef YOTTA_CFG_MBED_OS
kenjiArai 0:5b88d5760320 31 #include "mbed-drivers/mbed_error.h"
kenjiArai 0:5b88d5760320 32 #else
kenjiArai 0:5b88d5760320 33
kenjiArai 0:5b88d5760320 34 #include "platform/mbed_error.h"
kenjiArai 0:5b88d5760320 35
kenjiArai 0:5b88d5760320 36 #endif
kenjiArai 0:5b88d5760320 37
kenjiArai 0:5b88d5760320 38 #include "platform/mbed_toolchain.h"
kenjiArai 0:5b88d5760320 39
kenjiArai 0:5b88d5760320 40 /* Forward declaration for the implementation class */
kenjiArai 0:5b88d5760320 41 class BLEInstanceBase;
kenjiArai 0:5b88d5760320 42
kenjiArai 0:5b88d5760320 43 /**
kenjiArai 0:5b88d5760320 44 * @addtogroup ble
kenjiArai 0:5b88d5760320 45 * @{
kenjiArai 0:5b88d5760320 46 */
kenjiArai 0:5b88d5760320 47
kenjiArai 0:5b88d5760320 48 /**
kenjiArai 0:5b88d5760320 49 * Abstract away BLE-capable radio transceivers or SOCs.
kenjiArai 0:5b88d5760320 50 *
kenjiArai 0:5b88d5760320 51 * Instances of this class have three responsibilities:
kenjiArai 0:5b88d5760320 52 * - Initialize the inner BLE subsystem.
kenjiArai 0:5b88d5760320 53 * - Signal user code that BLE events are available and an API to process them.
kenjiArai 0:5b88d5760320 54 * - Manage access to the instances abstracting each BLE layer:
kenjiArai 0:5b88d5760320 55 * + GAP: Handle advertising and scan, as well as connection and
kenjiArai 0:5b88d5760320 56 * disconnection.
kenjiArai 0:5b88d5760320 57 * + GATTServer: API to construct and manage a GATT server, which connected peers can
kenjiArai 0:5b88d5760320 58 * access.
kenjiArai 0:5b88d5760320 59 * + GATTClient: API to interact with a peer GATT server.
kenjiArai 0:5b88d5760320 60 * + SecurityManager: API to manage security.
kenjiArai 0:5b88d5760320 61 *
kenjiArai 0:5b88d5760320 62 * The user should not create BLE instances directly but rather access to the
kenjiArai 0:5b88d5760320 63 * singleton(s) holding the BLE interfaces present in the system by using the
kenjiArai 0:5b88d5760320 64 * static function Instance().
kenjiArai 0:5b88d5760320 65 *
kenjiArai 0:5b88d5760320 66 * @code
kenjiArai 0:5b88d5760320 67 * #include "ble/BLE.h"
kenjiArai 0:5b88d5760320 68 *
kenjiArai 0:5b88d5760320 69 * BLE& ble_interface = BLE::Instance();
kenjiArai 0:5b88d5760320 70 * @endcode
kenjiArai 0:5b88d5760320 71 *
kenjiArai 0:5b88d5760320 72 * Next, the signal handling/process mechanism should be set up. By design,
kenjiArai 0:5b88d5760320 73 * Mbed BLE does not impose to the user an event handling/processing mechanism;
kenjiArai 0:5b88d5760320 74 * however, it exposes APIs, which allows an application to compose its own:
kenjiArai 0:5b88d5760320 75 * - onEventsToProcess(), which registers a callback that
kenjiArai 0:5b88d5760320 76 * the BLE subsystem will call when there is an event ready to be processed.
kenjiArai 0:5b88d5760320 77 * - processEvents(), which processes all the events present in the BLE subsystem.
kenjiArai 0:5b88d5760320 78 *
kenjiArai 0:5b88d5760320 79 * It is common to bind BLE event mechanism with Mbed EventQueue:
kenjiArai 0:5b88d5760320 80 *
kenjiArai 0:5b88d5760320 81 * @code
kenjiArai 0:5b88d5760320 82 * #include <events/mbed_events.h>
kenjiArai 0:5b88d5760320 83 * #include "ble/BLE.h"
kenjiArai 0:5b88d5760320 84 *
kenjiArai 0:5b88d5760320 85 * // declare the event queue, which the whole application will share.
kenjiArai 0:5b88d5760320 86 * static EventQueue event_queue(4 * EVENTS_EVENT_SIZE);
kenjiArai 0:5b88d5760320 87 *
kenjiArai 0:5b88d5760320 88 * // Function invoked when there is a BLE event available.
kenjiArai 0:5b88d5760320 89 * // Event processing is put into the event queue.
kenjiArai 0:5b88d5760320 90 * void schedule_ble_processing(BLE::OnEventsToProcessCallbackContext* context) {
kenjiArai 0:5b88d5760320 91 * event_queue.call(callback(&(context->ble), &BLE::processEvents));
kenjiArai 0:5b88d5760320 92 * }
kenjiArai 0:5b88d5760320 93 *
kenjiArai 0:5b88d5760320 94 * int main()
kenjiArai 0:5b88d5760320 95 * {
kenjiArai 0:5b88d5760320 96 * BLE &ble_interface = BLE::Instance();
kenjiArai 0:5b88d5760320 97 *
kenjiArai 0:5b88d5760320 98 * // Bind event signaling to schedule_ble_processing
kenjiArai 0:5b88d5760320 99 * ble_interface.onEventsToProcess(schedule_ble_processing);
kenjiArai 0:5b88d5760320 100 *
kenjiArai 0:5b88d5760320 101 * // Launch BLE initialisation
kenjiArai 0:5b88d5760320 102 *
kenjiArai 0:5b88d5760320 103 * // Dispatch events in the event queue
kenjiArai 0:5b88d5760320 104 * event_queue.dispatch_forever();
kenjiArai 0:5b88d5760320 105 * return 0;
kenjiArai 0:5b88d5760320 106 * }
kenjiArai 0:5b88d5760320 107 * @endcode
kenjiArai 0:5b88d5760320 108 *
kenjiArai 0:5b88d5760320 109 * Once the event processing mechanism is in place, the Bluetooth subsystem can
kenjiArai 0:5b88d5760320 110 * be initialized with the init() function. That function accepts in input a
kenjiArai 0:5b88d5760320 111 * callback, which will be invoked once the initialization process has finished.
kenjiArai 0:5b88d5760320 112 *
kenjiArai 0:5b88d5760320 113 * @code
kenjiArai 0:5b88d5760320 114 * void on_ble_init_complete(BLE::InitializationCompleteCallbackContext *context)
kenjiArai 0:5b88d5760320 115 * {
kenjiArai 0:5b88d5760320 116 * BLE& ble_interface = context->ble;
kenjiArai 0:5b88d5760320 117 * ble_error_t initialization_error = context->error;
kenjiArai 0:5b88d5760320 118 *
kenjiArai 0:5b88d5760320 119 * if (initialization_error) {
kenjiArai 0:5b88d5760320 120 * // handle error
kenjiArai 0:5b88d5760320 121 * return;
kenjiArai 0:5b88d5760320 122 * }
kenjiArai 0:5b88d5760320 123 *
kenjiArai 0:5b88d5760320 124 * // The BLE interface can be accessed now.
kenjiArai 0:5b88d5760320 125 * }
kenjiArai 0:5b88d5760320 126 *
kenjiArai 0:5b88d5760320 127 * int main() {
kenjiArai 0:5b88d5760320 128 * BLE &ble_interface = BLE::Instance();
kenjiArai 0:5b88d5760320 129 * ble_interface.onEventsToProcess(schedule_ble_processing);
kenjiArai 0:5b88d5760320 130 *
kenjiArai 0:5b88d5760320 131 * // Initialize the BLE interface
kenjiArai 0:5b88d5760320 132 * ble_interface.init(on_ble_init_complete);
kenjiArai 0:5b88d5760320 133 *
kenjiArai 0:5b88d5760320 134 * event_queue.dispatch_forever();
kenjiArai 0:5b88d5760320 135 * return 0;
kenjiArai 0:5b88d5760320 136 * }
kenjiArai 0:5b88d5760320 137 * @endcode
kenjiArai 0:5b88d5760320 138 */
kenjiArai 0:5b88d5760320 139 class BLE {
kenjiArai 0:5b88d5760320 140 public:
kenjiArai 0:5b88d5760320 141 /**
kenjiArai 0:5b88d5760320 142 * Opaque type used to store the ID of a BLE instance.
kenjiArai 0:5b88d5760320 143 */
kenjiArai 0:5b88d5760320 144 typedef unsigned InstanceID_t;
kenjiArai 0:5b88d5760320 145
kenjiArai 0:5b88d5760320 146 /**
kenjiArai 0:5b88d5760320 147 * The value of the BLE::InstanceID_t for the default BLE instance.
kenjiArai 0:5b88d5760320 148 */
kenjiArai 0:5b88d5760320 149 static const InstanceID_t DEFAULT_INSTANCE = 0;
kenjiArai 0:5b88d5760320 150
kenjiArai 0:5b88d5760320 151 #ifndef YOTTA_CFG_BLE_INSTANCES_COUNT
kenjiArai 0:5b88d5760320 152 /**
kenjiArai 0:5b88d5760320 153 * The number of permitted BLE instances for the application.
kenjiArai 0:5b88d5760320 154 */
kenjiArai 0:5b88d5760320 155 static const InstanceID_t NUM_INSTANCES = 1;
kenjiArai 0:5b88d5760320 156 #else
kenjiArai 0:5b88d5760320 157 /**
kenjiArai 0:5b88d5760320 158 * The number of permitted BLE instances for the application.
kenjiArai 0:5b88d5760320 159 */
kenjiArai 0:5b88d5760320 160 static const InstanceID_t NUM_INSTANCES = YOTTA_CFG_BLE_INSTANCES_COUNT;
kenjiArai 0:5b88d5760320 161 #endif
kenjiArai 0:5b88d5760320 162
kenjiArai 0:5b88d5760320 163 /**
kenjiArai 0:5b88d5760320 164 * Get a reference to the BLE singleton corresponding to a given interface.
kenjiArai 0:5b88d5760320 165 *
kenjiArai 0:5b88d5760320 166 * There is a static array of BLE singletons.
kenjiArai 0:5b88d5760320 167 *
kenjiArai 0:5b88d5760320 168 * @note Calling Instance() is preferred over constructing a BLE object
kenjiArai 0:5b88d5760320 169 * directly because it returns references to singletons.
kenjiArai 0:5b88d5760320 170 *
kenjiArai 0:5b88d5760320 171 * @param[in] id BLE Instance ID to get.
kenjiArai 0:5b88d5760320 172 *
kenjiArai 0:5b88d5760320 173 * @return A reference to a single object.
kenjiArai 0:5b88d5760320 174 *
kenjiArai 0:5b88d5760320 175 * @pre id shall be less than NUM_INSTANCES.
kenjiArai 0:5b88d5760320 176 */
kenjiArai 0:5b88d5760320 177 static BLE &Instance(InstanceID_t id = DEFAULT_INSTANCE);
kenjiArai 0:5b88d5760320 178
kenjiArai 0:5b88d5760320 179 /**
kenjiArai 0:5b88d5760320 180 * Fetch the ID of a BLE instance.
kenjiArai 0:5b88d5760320 181 *
kenjiArai 0:5b88d5760320 182 * @return Instance id of this BLE instance.
kenjiArai 0:5b88d5760320 183 */
kenjiArai 0:5b88d5760320 184 InstanceID_t getInstanceID(void) const
kenjiArai 0:5b88d5760320 185 {
kenjiArai 0:5b88d5760320 186 return instanceID;
kenjiArai 0:5b88d5760320 187 }
kenjiArai 0:5b88d5760320 188
kenjiArai 0:5b88d5760320 189 /**
kenjiArai 0:5b88d5760320 190 * Events to process event.
kenjiArai 0:5b88d5760320 191 *
kenjiArai 0:5b88d5760320 192 * Instances of OnEventsToProcessCallbackContext are passed to the event
kenjiArai 0:5b88d5760320 193 * handler registered with onEventsToProcess().
kenjiArai 0:5b88d5760320 194 */
kenjiArai 0:5b88d5760320 195 struct OnEventsToProcessCallbackContext {
kenjiArai 0:5b88d5760320 196 /**
kenjiArai 0:5b88d5760320 197 * The ble instance which have events to process.
kenjiArai 0:5b88d5760320 198 */
kenjiArai 0:5b88d5760320 199 BLE &ble;
kenjiArai 0:5b88d5760320 200 };
kenjiArai 0:5b88d5760320 201
kenjiArai 0:5b88d5760320 202 /**
kenjiArai 0:5b88d5760320 203 * Events to process event handler
kenjiArai 0:5b88d5760320 204 */
kenjiArai 0:5b88d5760320 205 typedef FunctionPointerWithContext<OnEventsToProcessCallbackContext *>
kenjiArai 0:5b88d5760320 206 OnEventsToProcessCallback_t;
kenjiArai 0:5b88d5760320 207
kenjiArai 0:5b88d5760320 208 /**
kenjiArai 0:5b88d5760320 209 * Register a callback called when the BLE stack has pending work.
kenjiArai 0:5b88d5760320 210 *
kenjiArai 0:5b88d5760320 211 * By registering a callback, application code can know when event processing
kenjiArai 0:5b88d5760320 212 * has to be scheduled.
kenjiArai 0:5b88d5760320 213 *
kenjiArai 0:5b88d5760320 214 * @param on_event_cb Callback invoked when there are new events to process.
kenjiArai 0:5b88d5760320 215 */
kenjiArai 0:5b88d5760320 216 void onEventsToProcess(const OnEventsToProcessCallback_t &on_event_cb);
kenjiArai 0:5b88d5760320 217
kenjiArai 0:5b88d5760320 218 /**
kenjiArai 0:5b88d5760320 219 * Process ALL pending events living in the BLE stack and return once all
kenjiArai 0:5b88d5760320 220 * events have been consumed.
kenjiArai 0:5b88d5760320 221 *
kenjiArai 0:5b88d5760320 222 * @see onEventsToProcess()
kenjiArai 0:5b88d5760320 223 */
kenjiArai 0:5b88d5760320 224 void processEvents();
kenjiArai 0:5b88d5760320 225
kenjiArai 0:5b88d5760320 226 /**
kenjiArai 0:5b88d5760320 227 * Initialization complete event.
kenjiArai 0:5b88d5760320 228 *
kenjiArai 0:5b88d5760320 229 * This event is generated at the end of the init() procedure and is passed
kenjiArai 0:5b88d5760320 230 * to the completion callback passed to init().
kenjiArai 0:5b88d5760320 231 */
kenjiArai 0:5b88d5760320 232 struct InitializationCompleteCallbackContext {
kenjiArai 0:5b88d5760320 233 /**
kenjiArai 0:5b88d5760320 234 * Reference to the BLE object that has been initialized
kenjiArai 0:5b88d5760320 235 */
kenjiArai 0:5b88d5760320 236 BLE &ble;
kenjiArai 0:5b88d5760320 237
kenjiArai 0:5b88d5760320 238 /**
kenjiArai 0:5b88d5760320 239 * Error status of the initialization.
kenjiArai 0:5b88d5760320 240 *
kenjiArai 0:5b88d5760320 241 * That value is set to BLE_ERROR_NONE if initialization completed
kenjiArai 0:5b88d5760320 242 * successfully or the appropriate error code otherwise.
kenjiArai 0:5b88d5760320 243 * */
kenjiArai 0:5b88d5760320 244 ble_error_t error;
kenjiArai 0:5b88d5760320 245 };
kenjiArai 0:5b88d5760320 246
kenjiArai 0:5b88d5760320 247 /**
kenjiArai 0:5b88d5760320 248 * Initialization complete event handler.
kenjiArai 0:5b88d5760320 249 *
kenjiArai 0:5b88d5760320 250 * @note There are two versions of init(). In addition to the
kenjiArai 0:5b88d5760320 251 * function-pointer, init() can also take an <Object, member> tuple as its
kenjiArai 0:5b88d5760320 252 * callback target. In case of the latter, the following declaration doesn't
kenjiArai 0:5b88d5760320 253 * apply.
kenjiArai 0:5b88d5760320 254 */
kenjiArai 0:5b88d5760320 255 typedef void (*InitializationCompleteCallback_t)(
kenjiArai 0:5b88d5760320 256 InitializationCompleteCallbackContext *context
kenjiArai 0:5b88d5760320 257 );
kenjiArai 0:5b88d5760320 258
kenjiArai 0:5b88d5760320 259 /**
kenjiArai 0:5b88d5760320 260 * Initialize the BLE controller/stack.
kenjiArai 0:5b88d5760320 261 *
kenjiArai 0:5b88d5760320 262 * init() hands control to the underlying BLE module to accomplish
kenjiArai 0:5b88d5760320 263 * initialization. This initialization may tacitly depend on other hardware
kenjiArai 0:5b88d5760320 264 * setup (such as clocks or power-modes) that happens early on during system
kenjiArai 0:5b88d5760320 265 * startup. It may not be safe to call init() from a global static context
kenjiArai 0:5b88d5760320 266 * where ordering is compiler-specific and can't be guaranteed - it is safe
kenjiArai 0:5b88d5760320 267 * to call BLE::init() from within main().
kenjiArai 0:5b88d5760320 268 *
kenjiArai 0:5b88d5760320 269 * @param[in] completion_cb A callback for when initialization completes for
kenjiArai 0:5b88d5760320 270 * a BLE instance. This is an optional parameter; if no callback is set up,
kenjiArai 0:5b88d5760320 271 * the application can still determine the status of initialization using
kenjiArai 0:5b88d5760320 272 * BLE::hasInitialized() (see below).
kenjiArai 0:5b88d5760320 273 *
kenjiArai 0:5b88d5760320 274 * @return BLE_ERROR_NONE if the initialization procedure started
kenjiArai 0:5b88d5760320 275 * successfully.
kenjiArai 0:5b88d5760320 276 *
kenjiArai 0:5b88d5760320 277 * @note If init() returns BLE_ERROR_NONE, the underlying stack must invoke
kenjiArai 0:5b88d5760320 278 * the initialization completion callback at some point.
kenjiArai 0:5b88d5760320 279 *
kenjiArai 0:5b88d5760320 280 * @note Nearly all BLE APIs would return BLE_ERROR_INITIALIZATION_INCOMPLETE
kenjiArai 0:5b88d5760320 281 * if used on an instance before the corresponding transport is initialized.
kenjiArai 0:5b88d5760320 282 *
kenjiArai 0:5b88d5760320 283 * @note There are two versions of init(). In addition to the
kenjiArai 0:5b88d5760320 284 * function-pointer, init() can also take an <Object, member> pair as its
kenjiArai 0:5b88d5760320 285 * callback target.
kenjiArai 0:5b88d5760320 286 *
kenjiArai 0:5b88d5760320 287 * @attention This should be called before using anything else in the BLE
kenjiArai 0:5b88d5760320 288 * API.
kenjiArai 0:5b88d5760320 289 */
kenjiArai 0:5b88d5760320 290 ble_error_t init(InitializationCompleteCallback_t completion_cb = NULL)
kenjiArai 0:5b88d5760320 291 {
kenjiArai 0:5b88d5760320 292 FunctionPointerWithContext<InitializationCompleteCallbackContext *> callback(completion_cb);
kenjiArai 0:5b88d5760320 293 return initImplementation(callback);
kenjiArai 0:5b88d5760320 294 }
kenjiArai 0:5b88d5760320 295
kenjiArai 0:5b88d5760320 296 /**
kenjiArai 0:5b88d5760320 297 * Initialize the BLE controller/stack.
kenjiArai 0:5b88d5760320 298 *
kenjiArai 0:5b88d5760320 299 * This is an alternate declaration for init(). This one takes an
kenjiArai 0:5b88d5760320 300 * <Object, member> pair as its callback target.
kenjiArai 0:5b88d5760320 301 *
kenjiArai 0:5b88d5760320 302 * @param[in] object Object, which will be used to invoke the completion callback.
kenjiArai 0:5b88d5760320 303 * @param[in] completion_cb Member function pointer, which will be invoked when
kenjiArai 0:5b88d5760320 304 * initialization is complete.
kenjiArai 0:5b88d5760320 305 */
kenjiArai 0:5b88d5760320 306 template<typename T>
kenjiArai 0:5b88d5760320 307 ble_error_t init(T *object, void (T::*completion_cb)(InitializationCompleteCallbackContext *context))
kenjiArai 0:5b88d5760320 308 {
kenjiArai 0:5b88d5760320 309 FunctionPointerWithContext<InitializationCompleteCallbackContext *> callback(object, completion_cb);
kenjiArai 0:5b88d5760320 310 return initImplementation(callback);
kenjiArai 0:5b88d5760320 311 }
kenjiArai 0:5b88d5760320 312
kenjiArai 0:5b88d5760320 313 /**
kenjiArai 0:5b88d5760320 314 * Indicate if the BLE instance has been initialized.
kenjiArai 0:5b88d5760320 315 *
kenjiArai 0:5b88d5760320 316 * @return true if initialization has completed for the underlying BLE
kenjiArai 0:5b88d5760320 317 * transport.
kenjiArai 0:5b88d5760320 318 *
kenjiArai 0:5b88d5760320 319 * @note The application should set up a callback to signal completion of
kenjiArai 0:5b88d5760320 320 * initialization when using init().
kenjiArai 0:5b88d5760320 321 */
kenjiArai 0:5b88d5760320 322 bool hasInitialized(void) const;
kenjiArai 0:5b88d5760320 323
kenjiArai 0:5b88d5760320 324 /**
kenjiArai 0:5b88d5760320 325 * Shut down the underlying stack, and reset state of this BLE instance.
kenjiArai 0:5b88d5760320 326 *
kenjiArai 0:5b88d5760320 327 * @return BLE_ERROR_NONE if the instance was shut down without error or the
kenjiArai 0:5b88d5760320 328 * appropriate error code.
kenjiArai 0:5b88d5760320 329 *
kenjiArai 0:5b88d5760320 330 * @attention init() must be called afterward to reinstate services and
kenjiArai 0:5b88d5760320 331 * GAP state. This API offers a way to repopulate the GATT database with new
kenjiArai 0:5b88d5760320 332 * services and characteristics.
kenjiArai 0:5b88d5760320 333 */
kenjiArai 0:5b88d5760320 334 ble_error_t shutdown(void);
kenjiArai 0:5b88d5760320 335
kenjiArai 0:5b88d5760320 336 /**
kenjiArai 0:5b88d5760320 337 * This call allows the application to get the BLE stack version information.
kenjiArai 0:5b88d5760320 338 *
kenjiArai 0:5b88d5760320 339 * @return A pointer to a const string representing the version.
kenjiArai 0:5b88d5760320 340 *
kenjiArai 0:5b88d5760320 341 * @note The BLE API owns the string returned.
kenjiArai 0:5b88d5760320 342 */
kenjiArai 0:5b88d5760320 343 const char *getVersion(void);
kenjiArai 0:5b88d5760320 344
kenjiArai 0:5b88d5760320 345 /**
kenjiArai 0:5b88d5760320 346 * Accessor to Gap. All Gap-related functionality requires going through
kenjiArai 0:5b88d5760320 347 * this accessor.
kenjiArai 0:5b88d5760320 348 *
kenjiArai 0:5b88d5760320 349 * @return A reference to a Gap object associated to this BLE instance.
kenjiArai 0:5b88d5760320 350 */
kenjiArai 0:5b88d5760320 351 Gap &gap();
kenjiArai 0:5b88d5760320 352
kenjiArai 0:5b88d5760320 353 /**
kenjiArai 0:5b88d5760320 354 * A const alternative to gap().
kenjiArai 0:5b88d5760320 355 *
kenjiArai 0:5b88d5760320 356 * @return A const reference to a Gap object associated to this BLE instance.
kenjiArai 0:5b88d5760320 357 */
kenjiArai 0:5b88d5760320 358 const Gap &gap() const;
kenjiArai 0:5b88d5760320 359
kenjiArai 0:5b88d5760320 360 #if BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 361 /**
kenjiArai 0:5b88d5760320 362 * Accessor to GattServer. All GattServer related functionality requires
kenjiArai 0:5b88d5760320 363 * going through this accessor.
kenjiArai 0:5b88d5760320 364 *
kenjiArai 0:5b88d5760320 365 * @return A reference to a GattServer object associated to this BLE instance.
kenjiArai 0:5b88d5760320 366 */
kenjiArai 0:5b88d5760320 367 GattServer &gattServer();
kenjiArai 0:5b88d5760320 368
kenjiArai 0:5b88d5760320 369 /**
kenjiArai 0:5b88d5760320 370 * A const alternative to gattServer().
kenjiArai 0:5b88d5760320 371 *
kenjiArai 0:5b88d5760320 372 * @return A const reference to a GattServer object associated to this BLE
kenjiArai 0:5b88d5760320 373 * instance.
kenjiArai 0:5b88d5760320 374 */
kenjiArai 0:5b88d5760320 375 const GattServer &gattServer() const;
kenjiArai 0:5b88d5760320 376 #endif // BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 377
kenjiArai 0:5b88d5760320 378 #if BLE_FEATURE_GATT_CLIENT
kenjiArai 0:5b88d5760320 379 /**
kenjiArai 0:5b88d5760320 380 * Accessors to GattClient. All GattClient related functionality requires
kenjiArai 0:5b88d5760320 381 * going through this accessor.
kenjiArai 0:5b88d5760320 382 *
kenjiArai 0:5b88d5760320 383 * @return A reference to a GattClient object associated to this BLE instance.
kenjiArai 0:5b88d5760320 384 */
kenjiArai 0:5b88d5760320 385 GattClient &gattClient();
kenjiArai 0:5b88d5760320 386
kenjiArai 0:5b88d5760320 387 /**
kenjiArai 0:5b88d5760320 388 * A const alternative to gattClient().
kenjiArai 0:5b88d5760320 389 *
kenjiArai 0:5b88d5760320 390 * @return A const reference to a GattClient object associated to this BLE
kenjiArai 0:5b88d5760320 391 * instance.
kenjiArai 0:5b88d5760320 392 */
kenjiArai 0:5b88d5760320 393 const GattClient &gattClient() const;
kenjiArai 0:5b88d5760320 394 #endif // BLE_FEATURE_GATT_CLIENT
kenjiArai 0:5b88d5760320 395
kenjiArai 0:5b88d5760320 396 #if BLE_FEATURE_SECURITY
kenjiArai 0:5b88d5760320 397 /**
kenjiArai 0:5b88d5760320 398 * Accessors to SecurityManager. All SecurityManager-related functionality
kenjiArai 0:5b88d5760320 399 * requires going through this accessor.
kenjiArai 0:5b88d5760320 400 *
kenjiArai 0:5b88d5760320 401 * @return A reference to a SecurityManager object associated to this BLE
kenjiArai 0:5b88d5760320 402 * instance.
kenjiArai 0:5b88d5760320 403 */
kenjiArai 0:5b88d5760320 404 SecurityManager &securityManager();
kenjiArai 0:5b88d5760320 405
kenjiArai 0:5b88d5760320 406 /**
kenjiArai 0:5b88d5760320 407 * A const alternative to securityManager().
kenjiArai 0:5b88d5760320 408 *
kenjiArai 0:5b88d5760320 409 * @return A const reference to a SecurityManager object associated to this
kenjiArai 0:5b88d5760320 410 * BLE instance.
kenjiArai 0:5b88d5760320 411 */
kenjiArai 0:5b88d5760320 412 const SecurityManager &securityManager() const;
kenjiArai 0:5b88d5760320 413 #endif // BLE_FEATURE_SECURITY
kenjiArai 0:5b88d5760320 414
kenjiArai 0:5b88d5760320 415 /**
kenjiArai 0:5b88d5760320 416 * Translate error code into a printable string.
kenjiArai 0:5b88d5760320 417 *
kenjiArai 0:5b88d5760320 418 * @param[in] error Error code returned by BLE functions.
kenjiArai 0:5b88d5760320 419 *
kenjiArai 0:5b88d5760320 420 * @return A pointer to a const string describing the error.
kenjiArai 0:5b88d5760320 421 */
kenjiArai 0:5b88d5760320 422 static const char *errorToString(ble_error_t error);
kenjiArai 0:5b88d5760320 423
kenjiArai 0:5b88d5760320 424 /*
kenjiArai 0:5b88d5760320 425 * Deprecation alert!
kenjiArai 0:5b88d5760320 426 * All of the following are deprecated and may be dropped in a future
kenjiArai 0:5b88d5760320 427 * release. Documentation should refer to alternative APIs.
kenjiArai 0:5b88d5760320 428 */
kenjiArai 0:5b88d5760320 429 public:
kenjiArai 0:5b88d5760320 430 /**
kenjiArai 0:5b88d5760320 431 * Constructor for a handle to a BLE instance (the BLE stack). BLE handles
kenjiArai 0:5b88d5760320 432 * are thin wrappers around a transport object (that is, ptr. to
kenjiArai 0:5b88d5760320 433 * BLEInstanceBase).
kenjiArai 0:5b88d5760320 434 *
kenjiArai 0:5b88d5760320 435 * @param[in] instanceID BLE Instance ID to get.
kenjiArai 0:5b88d5760320 436 *
kenjiArai 0:5b88d5760320 437 * It is better to create BLE objects as singletons accessed through the
kenjiArai 0:5b88d5760320 438 * Instance() method. If multiple BLE handles are constructed for the same
kenjiArai 0:5b88d5760320 439 * interface (using this constructor), they share the same underlying
kenjiArai 0:5b88d5760320 440 * transport object.
kenjiArai 0:5b88d5760320 441 *
kenjiArai 0:5b88d5760320 442 * @deprecated Use the Instance() function instead of the constructor.
kenjiArai 0:5b88d5760320 443 */
kenjiArai 0:5b88d5760320 444 MBED_DEPRECATED("Use BLE::Instance() instead of BLE constructor.")
kenjiArai 0:5b88d5760320 445 BLE(InstanceID_t instanceID = DEFAULT_INSTANCE);
kenjiArai 0:5b88d5760320 446
kenjiArai 0:5b88d5760320 447 /**
kenjiArai 0:5b88d5760320 448 * Yield control to the BLE stack or to other tasks waiting for events.
kenjiArai 0:5b88d5760320 449 *
kenjiArai 0:5b88d5760320 450 * This is a sleep function that returns when there is an application-specific
kenjiArai 0:5b88d5760320 451 * interrupt. This is not interchangeable with WFE() considering that the
kenjiArai 0:5b88d5760320 452 * MCU might wake up several times to service the stack before returning
kenjiArai 0:5b88d5760320 453 * control to the caller.
kenjiArai 0:5b88d5760320 454 *
kenjiArai 0:5b88d5760320 455 * @deprecated This function blocks the CPU. Use the pair
kenjiArai 0:5b88d5760320 456 * onEventsToProcess() and processEvents().
kenjiArai 0:5b88d5760320 457 */
kenjiArai 0:5b88d5760320 458 MBED_DEPRECATED("Use BLE::processEvents() and BLE::onEventsToProcess().")
kenjiArai 0:5b88d5760320 459 void waitForEvent(void);
kenjiArai 0:5b88d5760320 460
kenjiArai 0:5b88d5760320 461 /**
kenjiArai 0:5b88d5760320 462 * Set the BTLE MAC address and type.
kenjiArai 0:5b88d5760320 463 *
kenjiArai 0:5b88d5760320 464 * @param[in] type Type of the address to set.
kenjiArai 0:5b88d5760320 465 * @param[in] address Value of the address to set. It is ordered in
kenjiArai 0:5b88d5760320 466 * little endian.
kenjiArai 0:5b88d5760320 467 *
kenjiArai 0:5b88d5760320 468 * @return BLE_ERROR_NONE on success.
kenjiArai 0:5b88d5760320 469 *
kenjiArai 0:5b88d5760320 470 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 471 * Gap::setAddress(). A former call to ble.setAddress(...) should be
kenjiArai 0:5b88d5760320 472 * replaced with ble.gap().setAddress(...).
kenjiArai 0:5b88d5760320 473 */
kenjiArai 0:5b88d5760320 474 MBED_DEPRECATED("Use ble.gap().setAddress(...)")
kenjiArai 0:5b88d5760320 475 ble_error_t setAddress(
kenjiArai 0:5b88d5760320 476 BLEProtocol::AddressType_t type,
kenjiArai 0:5b88d5760320 477 const BLEProtocol::AddressBytes_t address
kenjiArai 0:5b88d5760320 478 );
kenjiArai 0:5b88d5760320 479
kenjiArai 0:5b88d5760320 480 /**
kenjiArai 0:5b88d5760320 481 * Fetch the Bluetooth Low Energy MAC address and type.
kenjiArai 0:5b88d5760320 482 *
kenjiArai 0:5b88d5760320 483 * @param[out] typeP Type of the current address set.
kenjiArai 0:5b88d5760320 484 * @param[out] address Value of the current address.
kenjiArai 0:5b88d5760320 485 *
kenjiArai 0:5b88d5760320 486 * @return BLE_ERROR_NONE on success.
kenjiArai 0:5b88d5760320 487 *
kenjiArai 0:5b88d5760320 488 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 489 * Gap::getAddress(). A former call to ble.getAddress(...) should be
kenjiArai 0:5b88d5760320 490 * replaced with ble.gap().getAddress(...).
kenjiArai 0:5b88d5760320 491 */
kenjiArai 0:5b88d5760320 492 MBED_DEPRECATED("Use ble.gap().getAddress(...)")
kenjiArai 0:5b88d5760320 493 ble_error_t getAddress(
kenjiArai 0:5b88d5760320 494 BLEProtocol::AddressType_t *typeP, BLEProtocol::AddressBytes_t address
kenjiArai 0:5b88d5760320 495 )
kenjiArai 0:5b88d5760320 496 {
kenjiArai 0:5b88d5760320 497 return gap().getAddress(typeP, address);
kenjiArai 0:5b88d5760320 498 }
kenjiArai 0:5b88d5760320 499
kenjiArai 0:5b88d5760320 500 #if BLE_ROLE_BROADCASTER
kenjiArai 0:5b88d5760320 501 /**
kenjiArai 0:5b88d5760320 502 * Set the GAP advertising mode to use for this device.
kenjiArai 0:5b88d5760320 503 *
kenjiArai 0:5b88d5760320 504 * @param[in] advType New type of advertising to use.
kenjiArai 0:5b88d5760320 505 *
kenjiArai 0:5b88d5760320 506 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 507 * Gap::setAdvertisingType(). A former call to
kenjiArai 0:5b88d5760320 508 * ble.setAdvertisingType(...) should be replaced with
kenjiArai 0:5b88d5760320 509 * ble.gap().setAdvertisingType(...).
kenjiArai 0:5b88d5760320 510 */
kenjiArai 0:5b88d5760320 511 MBED_DEPRECATED("Use ble.gap().setAdvertisingType(...)")
kenjiArai 0:5b88d5760320 512 void setAdvertisingType(GapAdvertisingParams::AdvertisingType advType);
kenjiArai 0:5b88d5760320 513
kenjiArai 0:5b88d5760320 514 /**
kenjiArai 0:5b88d5760320 515 * Set the advertising interval.
kenjiArai 0:5b88d5760320 516 *
kenjiArai 0:5b88d5760320 517 * @param[in] interval
kenjiArai 0:5b88d5760320 518 * Advertising interval in units of milliseconds. Advertising
kenjiArai 0:5b88d5760320 519 * is disabled if interval is 0. If interval is smaller than
kenjiArai 0:5b88d5760320 520 * the minimum supported value, then the minimum supported
kenjiArai 0:5b88d5760320 521 * value is used instead. This minimum value can be discovered
kenjiArai 0:5b88d5760320 522 * using getMinAdvertisingInterval().
kenjiArai 0:5b88d5760320 523 *
kenjiArai 0:5b88d5760320 524 * This field must be set to 0 if connectionMode is equal
kenjiArai 0:5b88d5760320 525 * to ADV_CONNECTABLE_DIRECTED.
kenjiArai 0:5b88d5760320 526 *
kenjiArai 0:5b88d5760320 527 * @note Decreasing this value allows central devices to detect a
kenjiArai 0:5b88d5760320 528 * peripheral faster at the expense of more power being used by the radio
kenjiArai 0:5b88d5760320 529 * due to the higher data transmit rate.
kenjiArai 0:5b88d5760320 530 *
kenjiArai 0:5b88d5760320 531 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 532 * Gap::setAdvertisingInterval(). A former call to
kenjiArai 0:5b88d5760320 533 * ble.setAdvertisingInterval(...) should be replaced with
kenjiArai 0:5b88d5760320 534 * ble.gap().setAdvertisingInterval(...).
kenjiArai 0:5b88d5760320 535 *
kenjiArai 0:5b88d5760320 536 * @note WARNING: This API previously used 0.625ms as the unit for its
kenjiArai 0:5b88d5760320 537 * 'interval' argument. That required an explicit conversion from
kenjiArai 0:5b88d5760320 538 * milliseconds using Gap::MSEC_TO_GAP_DURATION_UNITS(). This conversion is
kenjiArai 0:5b88d5760320 539 * no longer required as the new units are milliseconds. Any application
kenjiArai 0:5b88d5760320 540 * code depending on the old semantics needs to be updated accordingly.
kenjiArai 0:5b88d5760320 541 */
kenjiArai 0:5b88d5760320 542 MBED_DEPRECATED("Use ble.gap().setAdvertisingInterval(...)")
kenjiArai 0:5b88d5760320 543 void setAdvertisingInterval(uint16_t interval);
kenjiArai 0:5b88d5760320 544
kenjiArai 0:5b88d5760320 545 /**
kenjiArai 0:5b88d5760320 546 * Get the minimum advertising interval in milliseconds, which can be used
kenjiArai 0:5b88d5760320 547 * for connectable advertising types.
kenjiArai 0:5b88d5760320 548 *
kenjiArai 0:5b88d5760320 549 * @return Minimum Advertising interval in milliseconds.
kenjiArai 0:5b88d5760320 550 *
kenjiArai 0:5b88d5760320 551 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 552 * Gap::getMinAdvertisingInterval(). A former call to
kenjiArai 0:5b88d5760320 553 * ble.getMinAdvertisingInterval(...) should be replaced with
kenjiArai 0:5b88d5760320 554 * ble.gap().getMinAdvertisingInterval(...).
kenjiArai 0:5b88d5760320 555 */
kenjiArai 0:5b88d5760320 556 MBED_DEPRECATED("Use ble.gap().getMinAdvertisingInterval(...)")
kenjiArai 0:5b88d5760320 557 uint16_t getMinAdvertisingInterval(void) const
kenjiArai 0:5b88d5760320 558 {
kenjiArai 0:5b88d5760320 559 return gap().getMinAdvertisingInterval();
kenjiArai 0:5b88d5760320 560 }
kenjiArai 0:5b88d5760320 561
kenjiArai 0:5b88d5760320 562 /**
kenjiArai 0:5b88d5760320 563 * Get the minimum advertising interval in milliseconds, which can be
kenjiArai 0:5b88d5760320 564 * used for nonconnectable advertising type.
kenjiArai 0:5b88d5760320 565 *
kenjiArai 0:5b88d5760320 566 * @return Minimum Advertising interval in milliseconds for nonconnectible mode.
kenjiArai 0:5b88d5760320 567 *
kenjiArai 0:5b88d5760320 568 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 569 * Gap::MinNonConnectableAdvertisingInterval(). A former call to
kenjiArai 0:5b88d5760320 570 * ble.getMinNonConnectableAdvertisingInterval(...) should be replaced with
kenjiArai 0:5b88d5760320 571 * ble.gap().getMinNonConnectableAdvertisingInterval(...).
kenjiArai 0:5b88d5760320 572 */
kenjiArai 0:5b88d5760320 573 MBED_DEPRECATED("Use ble.gap().getMinNonConnectableAdvertisingInterval(...)")
kenjiArai 0:5b88d5760320 574 uint16_t getMinNonConnectableAdvertisingInterval(void) const
kenjiArai 0:5b88d5760320 575 {
kenjiArai 0:5b88d5760320 576 return gap().getMinNonConnectableAdvertisingInterval();
kenjiArai 0:5b88d5760320 577 }
kenjiArai 0:5b88d5760320 578
kenjiArai 0:5b88d5760320 579 /**
kenjiArai 0:5b88d5760320 580 * Get the maximum advertising interval in milliseconds.
kenjiArai 0:5b88d5760320 581 *
kenjiArai 0:5b88d5760320 582 * @return Maximum Advertising interval in milliseconds.
kenjiArai 0:5b88d5760320 583 *
kenjiArai 0:5b88d5760320 584 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 585 * Gap::getMaxAdvertisingInterval(). A former call to
kenjiArai 0:5b88d5760320 586 * ble.getMaxAdvertisingInterval(...) should be replaced with
kenjiArai 0:5b88d5760320 587 * ble.gap().getMaxAdvertisingInterval(...).
kenjiArai 0:5b88d5760320 588 */
kenjiArai 0:5b88d5760320 589 MBED_DEPRECATED("Use ble.gap().getMaxAdvertisingInterval(...)")
kenjiArai 0:5b88d5760320 590 uint16_t getMaxAdvertisingInterval(void) const
kenjiArai 0:5b88d5760320 591 {
kenjiArai 0:5b88d5760320 592 return gap().getMaxAdvertisingInterval();
kenjiArai 0:5b88d5760320 593 }
kenjiArai 0:5b88d5760320 594
kenjiArai 0:5b88d5760320 595 /**
kenjiArai 0:5b88d5760320 596 * Set the advertising duration.
kenjiArai 0:5b88d5760320 597 *
kenjiArai 0:5b88d5760320 598 * A timeout event is genenerated once the advertising period expired.
kenjiArai 0:5b88d5760320 599 *
kenjiArai 0:5b88d5760320 600 * @param[in] timeout
kenjiArai 0:5b88d5760320 601 * Advertising timeout (in seconds) between 0x1 and 0x3FFF (1
kenjiArai 0:5b88d5760320 602 * and 16383). Use 0 to disable the advertising timeout.
kenjiArai 0:5b88d5760320 603 *
kenjiArai 0:5b88d5760320 604 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 605 * Gap::setAdvertisingTimeout(). A former call to
kenjiArai 0:5b88d5760320 606 * ble.setAdvertisingTimeout(...) should be replaced with
kenjiArai 0:5b88d5760320 607 * ble.gap().setAdvertisingTimeout(...).
kenjiArai 0:5b88d5760320 608 */
kenjiArai 0:5b88d5760320 609 MBED_DEPRECATED("Use ble.gap().setAdvertisingTimeout(...)")
kenjiArai 0:5b88d5760320 610 void setAdvertisingTimeout(uint16_t timeout);
kenjiArai 0:5b88d5760320 611
kenjiArai 0:5b88d5760320 612 /**
kenjiArai 0:5b88d5760320 613 * Set up a particular, user-constructed set of advertisement parameters for
kenjiArai 0:5b88d5760320 614 * the underlying stack. It would be uncommon for this API to be used
kenjiArai 0:5b88d5760320 615 * directly; there are other APIs to tweak advertisement parameters
kenjiArai 0:5b88d5760320 616 * individually (see above).
kenjiArai 0:5b88d5760320 617 *
kenjiArai 0:5b88d5760320 618 * @param[in] advParams The new advertising parameters.
kenjiArai 0:5b88d5760320 619 *
kenjiArai 0:5b88d5760320 620 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 621 * Gap::setAdvertisingParams(). A former call to
kenjiArai 0:5b88d5760320 622 * ble.setAdvertisingParams(...) should be replaced with
kenjiArai 0:5b88d5760320 623 * ble.gap().setAdvertisingParams(...).
kenjiArai 0:5b88d5760320 624 */
kenjiArai 0:5b88d5760320 625 MBED_DEPRECATED("Use ble.gap().setAdvertisingParams(...)")
kenjiArai 0:5b88d5760320 626 void setAdvertisingParams(const GapAdvertisingParams &advParams);
kenjiArai 0:5b88d5760320 627
kenjiArai 0:5b88d5760320 628 /**
kenjiArai 0:5b88d5760320 629 * Get the current advertising parameters.
kenjiArai 0:5b88d5760320 630 *
kenjiArai 0:5b88d5760320 631 * @return Read back advertising parameters. Useful for storing and
kenjiArai 0:5b88d5760320 632 * restoring parameters rapidly.
kenjiArai 0:5b88d5760320 633 *
kenjiArai 0:5b88d5760320 634 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 635 * Gap::getAdvertisingParams(). A former call to
kenjiArai 0:5b88d5760320 636 * ble.getAdvertisingParams(...) should be replaced with
kenjiArai 0:5b88d5760320 637 * ble.gap().getAdvertisingParams(...).
kenjiArai 0:5b88d5760320 638 */
kenjiArai 0:5b88d5760320 639 MBED_DEPRECATED("Use ble.gap().getAdvertisingParams(...)")
kenjiArai 0:5b88d5760320 640 const GapAdvertisingParams &getAdvertisingParams(void) const;
kenjiArai 0:5b88d5760320 641
kenjiArai 0:5b88d5760320 642 /**
kenjiArai 0:5b88d5760320 643 * Accumulate an AD structure in the advertising payload. Please note that
kenjiArai 0:5b88d5760320 644 * the payload is limited to 31 bytes. The SCAN_RESPONSE message may be used
kenjiArai 0:5b88d5760320 645 * as an additional 31 bytes if the advertising payload is too
kenjiArai 0:5b88d5760320 646 * small.
kenjiArai 0:5b88d5760320 647 *
kenjiArai 0:5b88d5760320 648 * @param[in] flags
kenjiArai 0:5b88d5760320 649 * The flags to add. Please refer to
kenjiArai 0:5b88d5760320 650 * GapAdvertisingData::Flags for valid flags. Multiple
kenjiArai 0:5b88d5760320 651 * flags may be specified in combination.
kenjiArai 0:5b88d5760320 652 *
kenjiArai 0:5b88d5760320 653 * @return BLE_ERROR_NONE if the data was successfully added to the
kenjiArai 0:5b88d5760320 654 * advertising payload.
kenjiArai 0:5b88d5760320 655 *
kenjiArai 0:5b88d5760320 656 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 657 * Gap::accumulateAdvertisingPayload(uint8_t). A former call to
kenjiArai 0:5b88d5760320 658 * ble.accumulateAdvertisingPayload(flags) should be replaced with
kenjiArai 0:5b88d5760320 659 * ble.gap().accumulateAdvertisingPayload(flags).
kenjiArai 0:5b88d5760320 660 */
kenjiArai 0:5b88d5760320 661 MBED_DEPRECATED("Use ble.gap().accumulateAdvertisingPayload(flags)")
kenjiArai 0:5b88d5760320 662 ble_error_t accumulateAdvertisingPayload(uint8_t flags);
kenjiArai 0:5b88d5760320 663
kenjiArai 0:5b88d5760320 664 /**
kenjiArai 0:5b88d5760320 665 * Accumulate an AD structure in the advertising payload. Please note that
kenjiArai 0:5b88d5760320 666 * the payload is limited to 31 bytes. The SCAN_RESPONSE message may be used
kenjiArai 0:5b88d5760320 667 * as an additional 31 bytes if the advertising payload is too
kenjiArai 0:5b88d5760320 668 * small.
kenjiArai 0:5b88d5760320 669 *
kenjiArai 0:5b88d5760320 670 * @param[in] app
kenjiArai 0:5b88d5760320 671 * The appearance of the peripheral.
kenjiArai 0:5b88d5760320 672 *
kenjiArai 0:5b88d5760320 673 * @return BLE_ERROR_NONE if the data was successfully added to the
kenjiArai 0:5b88d5760320 674 * advertising payload.
kenjiArai 0:5b88d5760320 675 *
kenjiArai 0:5b88d5760320 676 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 677 * Gap::accumulateAdvertisingPayload(GapAdvertisingData::Appearance).
kenjiArai 0:5b88d5760320 678 * A former call to ble.accumulateAdvertisingPayload(appearance)
kenjiArai 0:5b88d5760320 679 * should be replaced with
kenjiArai 0:5b88d5760320 680 * ble.gap().accumulateAdvertisingPayload(appearance).
kenjiArai 0:5b88d5760320 681 */
kenjiArai 0:5b88d5760320 682 MBED_DEPRECATED("Use ble.gap().accumulateAdvertisingPayload(appearance)")
kenjiArai 0:5b88d5760320 683 ble_error_t accumulateAdvertisingPayload(GapAdvertisingData::Appearance app);
kenjiArai 0:5b88d5760320 684
kenjiArai 0:5b88d5760320 685 /**
kenjiArai 0:5b88d5760320 686 * Accumulate an AD structure in the advertising payload. Please note that
kenjiArai 0:5b88d5760320 687 * the payload is limited to 31 bytes. The SCAN_RESPONSE message may be used
kenjiArai 0:5b88d5760320 688 * as an additional 31 bytes if the advertising payload is too
kenjiArai 0:5b88d5760320 689 * small.
kenjiArai 0:5b88d5760320 690 *
kenjiArai 0:5b88d5760320 691 * @param[in] power
kenjiArai 0:5b88d5760320 692 * The max transmit power to be used by the controller. This
kenjiArai 0:5b88d5760320 693 * is only a hint.
kenjiArai 0:5b88d5760320 694 *
kenjiArai 0:5b88d5760320 695 * @return BLE_ERROR_NONE if the data was successfully added to the
kenjiArai 0:5b88d5760320 696 * advertising payload.
kenjiArai 0:5b88d5760320 697 *
kenjiArai 0:5b88d5760320 698 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 699 * Gap::accumulateAdvertisingPayloadTxPower(). A former call to
kenjiArai 0:5b88d5760320 700 * ble.accumulateAdvertisingPayloadTxPower(txPower) should be replaced with
kenjiArai 0:5b88d5760320 701 * ble.gap().accumulateAdvertisingPayloadTxPower(txPower).
kenjiArai 0:5b88d5760320 702 */
kenjiArai 0:5b88d5760320 703 MBED_DEPRECATED("Use ble.gap().accumulateAdvertisingPayloadTxPower(...)")
kenjiArai 0:5b88d5760320 704 ble_error_t accumulateAdvertisingPayloadTxPower(int8_t power);
kenjiArai 0:5b88d5760320 705
kenjiArai 0:5b88d5760320 706 /**
kenjiArai 0:5b88d5760320 707 * Accumulate a variable length byte-stream as an AD structure in the
kenjiArai 0:5b88d5760320 708 * advertising payload. Please note that the payload is limited to 31 bytes.
kenjiArai 0:5b88d5760320 709 * The SCAN_RESPONSE message may be used as an additional 31 bytes if the
kenjiArai 0:5b88d5760320 710 * advertising payload is too small.
kenjiArai 0:5b88d5760320 711 *
kenjiArai 0:5b88d5760320 712 * @param type The type that describes the variable length data.
kenjiArai 0:5b88d5760320 713 * @param data Data bytes.
kenjiArai 0:5b88d5760320 714 * @param len Data length.
kenjiArai 0:5b88d5760320 715 *
kenjiArai 0:5b88d5760320 716 * @return BLE_ERROR_NONE if the advertisement payload was updated based on
kenjiArai 0:5b88d5760320 717 * matching AD type; otherwise, an appropriate error.
kenjiArai 0:5b88d5760320 718 *
kenjiArai 0:5b88d5760320 719 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 720 * Gap::accumulateAdvertisingPayload(GapAdvertisingData::DataType, const uint8_t, uint8_t).
kenjiArai 0:5b88d5760320 721 * A former call to ble.accumulateAdvertisingPayload(...) should
kenjiArai 0:5b88d5760320 722 * be replaced with ble.gap().accumulateAdvertisingPayload(...).
kenjiArai 0:5b88d5760320 723 */
kenjiArai 0:5b88d5760320 724 MBED_DEPRECATED("Use ble.gap().accumulateAdvertisingPayload(...)")
kenjiArai 0:5b88d5760320 725 ble_error_t accumulateAdvertisingPayload(GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len);
kenjiArai 0:5b88d5760320 726
kenjiArai 0:5b88d5760320 727 /**
kenjiArai 0:5b88d5760320 728 * Set up a particular, user-constructed advertisement payload for the
kenjiArai 0:5b88d5760320 729 * underlying stack. It would be uncommon for this API to be used directly;
kenjiArai 0:5b88d5760320 730 * there are other APIs to build an advertisement payload (see above).
kenjiArai 0:5b88d5760320 731 *
kenjiArai 0:5b88d5760320 732 * @param[in] advData Advertising data to set.
kenjiArai 0:5b88d5760320 733 *
kenjiArai 0:5b88d5760320 734 * @return BLE_ERROR_NONE if the advertising data was set successfully.
kenjiArai 0:5b88d5760320 735 *
kenjiArai 0:5b88d5760320 736 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 737 * Gap::setAdvertisingData(). A former call to
kenjiArai 0:5b88d5760320 738 * ble.setAdvertisingData(...) should be replaced with
kenjiArai 0:5b88d5760320 739 * ble.gap().setAdvertisingPayload(...).
kenjiArai 0:5b88d5760320 740 */
kenjiArai 0:5b88d5760320 741 MBED_DEPRECATED("Use ble.gap().setAdvertisingData(...)")
kenjiArai 0:5b88d5760320 742 ble_error_t setAdvertisingData(const GapAdvertisingData &advData);
kenjiArai 0:5b88d5760320 743
kenjiArai 0:5b88d5760320 744 /**
kenjiArai 0:5b88d5760320 745 * Get a reference to the current advertising payload.
kenjiArai 0:5b88d5760320 746 *
kenjiArai 0:5b88d5760320 747 * @return Read back advertising data. Useful for storing and
kenjiArai 0:5b88d5760320 748 * restoring payload.
kenjiArai 0:5b88d5760320 749 *
kenjiArai 0:5b88d5760320 750 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 751 * Gap::getAdvertisingData(). A former call to
kenjiArai 0:5b88d5760320 752 * ble.getAdvertisingData(...) should be replaced with
kenjiArai 0:5b88d5760320 753 * ble.gap().getAdvertisingPayload()(...).
kenjiArai 0:5b88d5760320 754 */
kenjiArai 0:5b88d5760320 755 MBED_DEPRECATED("Use ble.gap().getAdvertisingData(...)")
kenjiArai 0:5b88d5760320 756 const GapAdvertisingData &getAdvertisingData(void) const;
kenjiArai 0:5b88d5760320 757
kenjiArai 0:5b88d5760320 758 /**
kenjiArai 0:5b88d5760320 759 * Reset any advertising payload prepared from prior calls to
kenjiArai 0:5b88d5760320 760 * accumulateAdvertisingPayload(). This automatically propagates the re-
kenjiArai 0:5b88d5760320 761 * initialized advertising payload to the underlying stack.
kenjiArai 0:5b88d5760320 762 *
kenjiArai 0:5b88d5760320 763 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 764 * Gap::clearAdvertisingPayload(). A former call to
kenjiArai 0:5b88d5760320 765 * ble.clearAdvertisingPayload(...) should be replaced with
kenjiArai 0:5b88d5760320 766 * ble.gap().clearAdvertisingPayload(...).
kenjiArai 0:5b88d5760320 767 */
kenjiArai 0:5b88d5760320 768 MBED_DEPRECATED("Use ble.gap().clearAdvertisingPayload(...)")
kenjiArai 0:5b88d5760320 769 void clearAdvertisingPayload(void);
kenjiArai 0:5b88d5760320 770
kenjiArai 0:5b88d5760320 771 /**
kenjiArai 0:5b88d5760320 772 * Dynamically reset the accumulated advertising
kenjiArai 0:5b88d5760320 773 * payload and scanResponse. The application must clear and re-
kenjiArai 0:5b88d5760320 774 * accumulate a new advertising payload (and scanResponse) before using this
kenjiArai 0:5b88d5760320 775 * API.
kenjiArai 0:5b88d5760320 776 *
kenjiArai 0:5b88d5760320 777 * @return BLE_ERROR_NONE when the advertising payload is set successfully.
kenjiArai 0:5b88d5760320 778 *
kenjiArai 0:5b88d5760320 779 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 780 * Gap::setAdvertisingPayload().
kenjiArai 0:5b88d5760320 781 *
kenjiArai 0:5b88d5760320 782 * @note The new APIs in Gap update the underlying advertisement payload
kenjiArai 0:5b88d5760320 783 * implicitly.
kenjiArai 0:5b88d5760320 784 */
kenjiArai 0:5b88d5760320 785 MBED_DEPRECATED("Use ble.gap().setAdvertisingPayload(...)")
kenjiArai 0:5b88d5760320 786 ble_error_t setAdvertisingPayload(void);
kenjiArai 0:5b88d5760320 787
kenjiArai 0:5b88d5760320 788 /**
kenjiArai 0:5b88d5760320 789 * Accumulate a variable length byte-stream as an AD structure in the
kenjiArai 0:5b88d5760320 790 * scanResponse payload.
kenjiArai 0:5b88d5760320 791 *
kenjiArai 0:5b88d5760320 792 * @param[in] type The type that describes the variable length data.
kenjiArai 0:5b88d5760320 793 * @param[in] data Data bytes.
kenjiArai 0:5b88d5760320 794 * @param[in] len Data length.
kenjiArai 0:5b88d5760320 795 *
kenjiArai 0:5b88d5760320 796 * @return BLE_ERROR_NONE if the data was successfully added to the scan
kenjiArai 0:5b88d5760320 797 * response payload.
kenjiArai 0:5b88d5760320 798 *
kenjiArai 0:5b88d5760320 799 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 800 * Gap::accumulateScanResponse(). A former call to
kenjiArai 0:5b88d5760320 801 * ble.accumulateScanResponse(...) should be replaced with
kenjiArai 0:5b88d5760320 802 * ble.gap().accumulateScanResponse(...).
kenjiArai 0:5b88d5760320 803 */
kenjiArai 0:5b88d5760320 804 MBED_DEPRECATED("Use ble.gap().accumulateScanResponse(...)")
kenjiArai 0:5b88d5760320 805 ble_error_t accumulateScanResponse(GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len);
kenjiArai 0:5b88d5760320 806
kenjiArai 0:5b88d5760320 807 /**
kenjiArai 0:5b88d5760320 808 * Reset any scan response prepared from prior calls to
kenjiArai 0:5b88d5760320 809 * accumulateScanResponse().
kenjiArai 0:5b88d5760320 810 *
kenjiArai 0:5b88d5760320 811 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 812 * Gap::clearScanResponse(). A former call to
kenjiArai 0:5b88d5760320 813 * ble.clearScanResponse(...) should be replaced with
kenjiArai 0:5b88d5760320 814 * ble.gap().clearScanResponse(...).
kenjiArai 0:5b88d5760320 815 */
kenjiArai 0:5b88d5760320 816 MBED_DEPRECATED("Use ble.gap().clearScanResponse(...)")
kenjiArai 0:5b88d5760320 817 void clearScanResponse(void);
kenjiArai 0:5b88d5760320 818
kenjiArai 0:5b88d5760320 819 /**
kenjiArai 0:5b88d5760320 820 * Start advertising.
kenjiArai 0:5b88d5760320 821 *
kenjiArai 0:5b88d5760320 822 * @return BLE_ERROR_NONE if the advertising procedure successfully
kenjiArai 0:5b88d5760320 823 * started.
kenjiArai 0:5b88d5760320 824 *
kenjiArai 0:5b88d5760320 825 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 826 * Gap::startAdvertising(). A former call to
kenjiArai 0:5b88d5760320 827 * ble.startAdvertising(...) should be replaced with
kenjiArai 0:5b88d5760320 828 * ble.gap().startAdvertising(...).
kenjiArai 0:5b88d5760320 829 */
kenjiArai 0:5b88d5760320 830 MBED_DEPRECATED("Use ble.gap().startAdvertising(...)")
kenjiArai 0:5b88d5760320 831 ble_error_t startAdvertising(void);
kenjiArai 0:5b88d5760320 832
kenjiArai 0:5b88d5760320 833 /**
kenjiArai 0:5b88d5760320 834 * Stop advertising.
kenjiArai 0:5b88d5760320 835 *
kenjiArai 0:5b88d5760320 836 * @return BLE_ERROR_NONE if the advertising procedure has been successfully
kenjiArai 0:5b88d5760320 837 * stopped.
kenjiArai 0:5b88d5760320 838 *
kenjiArai 0:5b88d5760320 839 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 840 * Gap::stopAdvertising(). A former call to
kenjiArai 0:5b88d5760320 841 * ble.stopAdvertising(...) should be replaced with
kenjiArai 0:5b88d5760320 842 * ble.gap().stopAdvertising(...).
kenjiArai 0:5b88d5760320 843 */
kenjiArai 0:5b88d5760320 844 MBED_DEPRECATED("Use ble.gap().stopAdvertising(...)")
kenjiArai 0:5b88d5760320 845 ble_error_t stopAdvertising(void);
kenjiArai 0:5b88d5760320 846 #endif // BLE_ROLE_BROADCASTER
kenjiArai 0:5b88d5760320 847
kenjiArai 0:5b88d5760320 848 #if BLE_ROLE_OBSERVER
kenjiArai 0:5b88d5760320 849 /**
kenjiArai 0:5b88d5760320 850 * Set up parameters for GAP scanning (observer mode).
kenjiArai 0:5b88d5760320 851 *
kenjiArai 0:5b88d5760320 852 * @param[in] interval
kenjiArai 0:5b88d5760320 853 * Scan interval (in milliseconds) [valid values lie between 2.5ms and 10.24s].
kenjiArai 0:5b88d5760320 854 * @param[in] window
kenjiArai 0:5b88d5760320 855 * Scan Window (in milliseconds) [valid values lie between 2.5ms and 10.24s].
kenjiArai 0:5b88d5760320 856 * @param[in] timeout
kenjiArai 0:5b88d5760320 857 * Scan timeout (in seconds) between 0x0001 and 0xFFFF; 0x0000 disables timeout.
kenjiArai 0:5b88d5760320 858 * @param[in] activeScanning
kenjiArai 0:5b88d5760320 859 * Set to True if active-scanning is required. This is used to fetch the
kenjiArai 0:5b88d5760320 860 * scan response from a peer if possible.
kenjiArai 0:5b88d5760320 861 *
kenjiArai 0:5b88d5760320 862 * @return BLE_ERROR_NONE if the scan parameters were correctly set.
kenjiArai 0:5b88d5760320 863 *
kenjiArai 0:5b88d5760320 864 * The scanning window divided by the interval determines the duty cycle for
kenjiArai 0:5b88d5760320 865 * scanning. For example, if the interval is 100ms and the window is 10ms,
kenjiArai 0:5b88d5760320 866 * then the controller will scan for 10 percent of the time. It is possible
kenjiArai 0:5b88d5760320 867 * to have the interval and window set to the same value. In this case,
kenjiArai 0:5b88d5760320 868 * scanning is continuous, with a change of scanning frequency once every
kenjiArai 0:5b88d5760320 869 * interval.
kenjiArai 0:5b88d5760320 870 *
kenjiArai 0:5b88d5760320 871 * Once the scanning parameters have been configured, scanning can be
kenjiArai 0:5b88d5760320 872 * enabled by using startScan().
kenjiArai 0:5b88d5760320 873 *
kenjiArai 0:5b88d5760320 874 * @note The scan interval and window are recommendations to the BLE stack.
kenjiArai 0:5b88d5760320 875 *
kenjiArai 0:5b88d5760320 876 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 877 * Gap::setScanParams(). A former call to
kenjiArai 0:5b88d5760320 878 * ble.setScanParams(...) should be replaced with
kenjiArai 0:5b88d5760320 879 * ble.gap().setScanParams(...).
kenjiArai 0:5b88d5760320 880 */
kenjiArai 0:5b88d5760320 881 MBED_DEPRECATED("Use ble.gap().setScanParams(...)")
kenjiArai 0:5b88d5760320 882 ble_error_t setScanParams(
kenjiArai 0:5b88d5760320 883 uint16_t interval = GapScanningParams::SCAN_INTERVAL_MAX,
kenjiArai 0:5b88d5760320 884 uint16_t window = GapScanningParams::SCAN_WINDOW_MAX,
kenjiArai 0:5b88d5760320 885 uint16_t timeout = 0,
kenjiArai 0:5b88d5760320 886 bool activeScanning = false
kenjiArai 0:5b88d5760320 887 );
kenjiArai 0:5b88d5760320 888
kenjiArai 0:5b88d5760320 889 /**
kenjiArai 0:5b88d5760320 890 * Set up the scanInterval parameter for GAP scanning (observer mode).
kenjiArai 0:5b88d5760320 891 *
kenjiArai 0:5b88d5760320 892 * @param[in] interval
kenjiArai 0:5b88d5760320 893 * Scan interval (in milliseconds) [valid values lie between 2.5ms and 10.24s].
kenjiArai 0:5b88d5760320 894 *
kenjiArai 0:5b88d5760320 895 * @return BLE_ERROR_NONE if the scan interval was correctly set.
kenjiArai 0:5b88d5760320 896 *
kenjiArai 0:5b88d5760320 897 * The scanning window divided by the interval determines the duty cycle for
kenjiArai 0:5b88d5760320 898 * scanning. For example, if the interval is 100ms and the window is 10ms,
kenjiArai 0:5b88d5760320 899 * then the controller will scan for 10 percent of the time. It is possible
kenjiArai 0:5b88d5760320 900 * to have the interval and window set to the same value. In this case,
kenjiArai 0:5b88d5760320 901 * scanning is continuous, with a change of scanning frequency once every
kenjiArai 0:5b88d5760320 902 * interval.
kenjiArai 0:5b88d5760320 903 *
kenjiArai 0:5b88d5760320 904 * Once the scanning parameters have been configured, scanning can be
kenjiArai 0:5b88d5760320 905 * enabled by using startScan().
kenjiArai 0:5b88d5760320 906 *
kenjiArai 0:5b88d5760320 907 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 908 * Gap::setScanInterval(). A former call to
kenjiArai 0:5b88d5760320 909 * ble.setScanInterval(interval) should be replaced with
kenjiArai 0:5b88d5760320 910 * ble.gap().setScanInterval(interval).
kenjiArai 0:5b88d5760320 911 */
kenjiArai 0:5b88d5760320 912 MBED_DEPRECATED("Use ble.gap().setScanInterval(...)")
kenjiArai 0:5b88d5760320 913 ble_error_t setScanInterval(uint16_t interval);
kenjiArai 0:5b88d5760320 914
kenjiArai 0:5b88d5760320 915 /**
kenjiArai 0:5b88d5760320 916 * Set up the scanWindow parameter for GAP scanning (observer mode).
kenjiArai 0:5b88d5760320 917 *
kenjiArai 0:5b88d5760320 918 * @param[in] window
kenjiArai 0:5b88d5760320 919 * Scan Window (in milliseconds) [valid values lie between 2.5ms and 10.24s].
kenjiArai 0:5b88d5760320 920 *
kenjiArai 0:5b88d5760320 921 * @return BLE_ERROR_NONE if the scan window was correctly set.
kenjiArai 0:5b88d5760320 922 *
kenjiArai 0:5b88d5760320 923 * The scanning window divided by the interval determines the duty cycle for
kenjiArai 0:5b88d5760320 924 * scanning. For example, if the interval is 100ms and the window is 10ms,
kenjiArai 0:5b88d5760320 925 * then the controller will scan for 10 percent of the time. It is possible
kenjiArai 0:5b88d5760320 926 * to have the interval and window set to the same value. In this case,
kenjiArai 0:5b88d5760320 927 * scanning is continuous, with a change of scanning frequency once every
kenjiArai 0:5b88d5760320 928 * interval.
kenjiArai 0:5b88d5760320 929 *
kenjiArai 0:5b88d5760320 930 * Once the scanning parameters have been configured, scanning can be
kenjiArai 0:5b88d5760320 931 * enabled by using startScan().
kenjiArai 0:5b88d5760320 932 *
kenjiArai 0:5b88d5760320 933 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 934 * Gap::setScanWindow(). A former call to
kenjiArai 0:5b88d5760320 935 * ble.setScanWindow(window) should be replaced with
kenjiArai 0:5b88d5760320 936 * ble.gap().setScanWindow(window).
kenjiArai 0:5b88d5760320 937 */
kenjiArai 0:5b88d5760320 938 MBED_DEPRECATED("Use ble.gap().setScanWindow(...)")
kenjiArai 0:5b88d5760320 939 ble_error_t setScanWindow(uint16_t window);
kenjiArai 0:5b88d5760320 940
kenjiArai 0:5b88d5760320 941 /**
kenjiArai 0:5b88d5760320 942 * Set up parameters for GAP scanning (observer mode).
kenjiArai 0:5b88d5760320 943 *
kenjiArai 0:5b88d5760320 944 * @param[in] timeout
kenjiArai 0:5b88d5760320 945 * Scan timeout (in seconds) between 0x0001 and 0xFFFF; 0x0000 disables timeout.
kenjiArai 0:5b88d5760320 946 *
kenjiArai 0:5b88d5760320 947 * @return BLE_ERROR_NONE if the scan timeout was correctly set.
kenjiArai 0:5b88d5760320 948 *
kenjiArai 0:5b88d5760320 949 * The scanning window divided by the interval determines the duty cycle for
kenjiArai 0:5b88d5760320 950 * scanning. For example, if the interval is 100ms and the window is 10ms,
kenjiArai 0:5b88d5760320 951 * then the controller will scan for 10 percent of the time. It is possible
kenjiArai 0:5b88d5760320 952 * to have the interval and window set to the same value. In this case,
kenjiArai 0:5b88d5760320 953 * scanning is continuous, with a change of scanning frequency once every
kenjiArai 0:5b88d5760320 954 * interval.
kenjiArai 0:5b88d5760320 955 *
kenjiArai 0:5b88d5760320 956 * Once the scanning parameters have been configured, scanning can be
kenjiArai 0:5b88d5760320 957 * enabled by using startScan().
kenjiArai 0:5b88d5760320 958 *
kenjiArai 0:5b88d5760320 959 * @note The scan interval and window are recommendations to the BLE stack.
kenjiArai 0:5b88d5760320 960 *
kenjiArai 0:5b88d5760320 961 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 962 * Gap::setScanTimeout(). A former call to
kenjiArai 0:5b88d5760320 963 * ble.setScanTimeout(...) should be replaced with
kenjiArai 0:5b88d5760320 964 * ble.gap().setScanTimeout(...).
kenjiArai 0:5b88d5760320 965 */
kenjiArai 0:5b88d5760320 966 MBED_DEPRECATED("Use ble.gap().setScanTimeout(...)")
kenjiArai 0:5b88d5760320 967 ble_error_t setScanTimeout(uint16_t timeout);
kenjiArai 0:5b88d5760320 968
kenjiArai 0:5b88d5760320 969 /**
kenjiArai 0:5b88d5760320 970 * Set up parameters for GAP scanning (observer mode).
kenjiArai 0:5b88d5760320 971 *
kenjiArai 0:5b88d5760320 972 * @param[in] activeScanning
kenjiArai 0:5b88d5760320 973 * Set to True if active-scanning is required. This is used to fetch the
kenjiArai 0:5b88d5760320 974 * scan response from a peer if possible.
kenjiArai 0:5b88d5760320 975 *
kenjiArai 0:5b88d5760320 976 * Once the scanning parameters have been configured, scanning can be
kenjiArai 0:5b88d5760320 977 * enabled by using startScan().
kenjiArai 0:5b88d5760320 978 *
kenjiArai 0:5b88d5760320 979 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 980 * Gap::setActiveScan(). A former call to
kenjiArai 0:5b88d5760320 981 * ble.setActiveScan(...) should be replaced with
kenjiArai 0:5b88d5760320 982 * ble.gap().setActiveScanning(...).
kenjiArai 0:5b88d5760320 983 */
kenjiArai 0:5b88d5760320 984 MBED_DEPRECATED("Use ble.gap().setActiveScan(...)")
kenjiArai 0:5b88d5760320 985 void setActiveScan(bool activeScanning);
kenjiArai 0:5b88d5760320 986
kenjiArai 0:5b88d5760320 987 /**
kenjiArai 0:5b88d5760320 988 * Start scanning (Observer Procedure) based on the parameters currently in
kenjiArai 0:5b88d5760320 989 * effect.
kenjiArai 0:5b88d5760320 990 *
kenjiArai 0:5b88d5760320 991 * @param[in] callback
kenjiArai 0:5b88d5760320 992 * The application-specific callback to be invoked upon
kenjiArai 0:5b88d5760320 993 * receiving every advertisement report. This can be passed in
kenjiArai 0:5b88d5760320 994 * as NULL, in which case scanning may not be enabled at all.
kenjiArai 0:5b88d5760320 995 *
kenjiArai 0:5b88d5760320 996 * @return BLE_ERROR_NONE if the device successfully started the scan
kenjiArai 0:5b88d5760320 997 * procedure.
kenjiArai 0:5b88d5760320 998 *
kenjiArai 0:5b88d5760320 999 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 1000 * Gap::startScan(). A former call to
kenjiArai 0:5b88d5760320 1001 * ble.startScan(callback) should be replaced with
kenjiArai 0:5b88d5760320 1002 * ble.gap().startScan(callback).
kenjiArai 0:5b88d5760320 1003 */
kenjiArai 0:5b88d5760320 1004 MBED_DEPRECATED("Use ble.gap().startScan(callback)")
kenjiArai 0:5b88d5760320 1005 ble_error_t startScan(void (*callback)(const Gap::AdvertisementCallbackParams_t *params));
kenjiArai 0:5b88d5760320 1006
kenjiArai 0:5b88d5760320 1007 /**
kenjiArai 0:5b88d5760320 1008 * Start the scanning procedure.
kenjiArai 0:5b88d5760320 1009 *
kenjiArai 0:5b88d5760320 1010 * Packets received during the scan procedure are forwarded to the
kenjiArai 0:5b88d5760320 1011 * scan packet handler passed as argument to this function.
kenjiArai 0:5b88d5760320 1012 *
kenjiArai 0:5b88d5760320 1013 * @param[in] object Instance used to invoke @p callbackMember.
kenjiArai 0:5b88d5760320 1014 *
kenjiArai 0:5b88d5760320 1015 * @param[in] memberCallback Advertisement packet event handler. Upon
kenjiArai 0:5b88d5760320 1016 * reception of an advertising packet, the packet is forwarded to @p
kenjiArai 0:5b88d5760320 1017 * callback invoked from @p object.
kenjiArai 0:5b88d5760320 1018 *
kenjiArai 0:5b88d5760320 1019 * @return BLE_ERROR_NONE if the device successfully started the scan
kenjiArai 0:5b88d5760320 1020 * procedure.
kenjiArai 0:5b88d5760320 1021 *
kenjiArai 0:5b88d5760320 1022 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 1023 * Gap::startScan(). A former call to
kenjiArai 0:5b88d5760320 1024 * ble.startScan(callback) should be replaced with
kenjiArai 0:5b88d5760320 1025 * ble.gap().startScan(object, callback).
kenjiArai 0:5b88d5760320 1026 */
kenjiArai 0:5b88d5760320 1027 template<typename T>
kenjiArai 0:5b88d5760320 1028 MBED_DEPRECATED("Use ble.gap().startScan(object, callback)")
kenjiArai 0:5b88d5760320 1029 ble_error_t startScan(T *object, void (T::*memberCallback)(const Gap::AdvertisementCallbackParams_t *params));
kenjiArai 0:5b88d5760320 1030
kenjiArai 0:5b88d5760320 1031 /**
kenjiArai 0:5b88d5760320 1032 * Stop scanning. The current scanning parameters remain in effect.
kenjiArai 0:5b88d5760320 1033 *
kenjiArai 0:5b88d5760320 1034 * @return BLE_ERROR_NONE if successfully stopped scanning procedure.
kenjiArai 0:5b88d5760320 1035 *
kenjiArai 0:5b88d5760320 1036 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1037 * Gap::stopScan(). A former call to
kenjiArai 0:5b88d5760320 1038 * ble.stopScan() should be replaced with
kenjiArai 0:5b88d5760320 1039 * ble.gap().stopScan().
kenjiArai 0:5b88d5760320 1040 */
kenjiArai 0:5b88d5760320 1041 MBED_DEPRECATED("Use ble.gap().stopScan()")
kenjiArai 0:5b88d5760320 1042 ble_error_t stopScan(void)
kenjiArai 0:5b88d5760320 1043 {
kenjiArai 0:5b88d5760320 1044 return gap().stopScan();
kenjiArai 0:5b88d5760320 1045 }
kenjiArai 0:5b88d5760320 1046 #endif // BLE_ROLE_OBSERVER
kenjiArai 0:5b88d5760320 1047
kenjiArai 0:5b88d5760320 1048 #if BLE_ROLE_CENTRAL
kenjiArai 0:5b88d5760320 1049 /**
kenjiArai 0:5b88d5760320 1050 * Create a connection (GAP Link Establishment).
kenjiArai 0:5b88d5760320 1051 *
kenjiArai 0:5b88d5760320 1052 * @param peerAddr
kenjiArai 0:5b88d5760320 1053 * 48-bit address, LSB format.
kenjiArai 0:5b88d5760320 1054 * @param peerAddrType
kenjiArai 0:5b88d5760320 1055 * Address type of the peer.
kenjiArai 0:5b88d5760320 1056 * @param connectionParams
kenjiArai 0:5b88d5760320 1057 * Connection parameters.
kenjiArai 0:5b88d5760320 1058 * @param scanParams
kenjiArai 0:5b88d5760320 1059 * Parameters to use while scanning for the peer.
kenjiArai 0:5b88d5760320 1060 *
kenjiArai 0:5b88d5760320 1061 * @return BLE_ERROR_NONE if connection establishment procedure is started
kenjiArai 0:5b88d5760320 1062 * successfully. The onConnection callback (if set) is invoked upon
kenjiArai 0:5b88d5760320 1063 * a connection event.
kenjiArai 0:5b88d5760320 1064 *
kenjiArai 0:5b88d5760320 1065 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1066 * Gap::connect(). A former call to
kenjiArai 0:5b88d5760320 1067 * ble.connect(...) should be replaced with
kenjiArai 0:5b88d5760320 1068 * ble.gap().connect(...).
kenjiArai 0:5b88d5760320 1069 */
kenjiArai 0:5b88d5760320 1070 MBED_DEPRECATED("Use ble.gap().connect(...)")
kenjiArai 0:5b88d5760320 1071 ble_error_t connect(
kenjiArai 0:5b88d5760320 1072 const BLEProtocol::AddressBytes_t peerAddr,
kenjiArai 0:5b88d5760320 1073 BLEProtocol::AddressType_t peerAddrType = BLEProtocol::AddressType::RANDOM_STATIC,
kenjiArai 0:5b88d5760320 1074 const Gap::ConnectionParams_t *connectionParams = NULL,
kenjiArai 0:5b88d5760320 1075 const GapScanningParams *scanParams = NULL
kenjiArai 0:5b88d5760320 1076 );
kenjiArai 0:5b88d5760320 1077 #endif // BLE_ROLE_CENTRAL
kenjiArai 0:5b88d5760320 1078
kenjiArai 0:5b88d5760320 1079 #if BLE_FEATURE_CONNECTABLE
kenjiArai 0:5b88d5760320 1080 /**
kenjiArai 0:5b88d5760320 1081 * This call initiates the disconnection procedure, and its completion is
kenjiArai 0:5b88d5760320 1082 * communicated to the application with an invocation of the
kenjiArai 0:5b88d5760320 1083 * onDisconnection callback.
kenjiArai 0:5b88d5760320 1084 *
kenjiArai 0:5b88d5760320 1085 * @param[in] connectionHandle
kenjiArai 0:5b88d5760320 1086 * @param[in] reason
kenjiArai 0:5b88d5760320 1087 * The reason for disconnection; sent back to the peer.
kenjiArai 0:5b88d5760320 1088 *
kenjiArai 0:5b88d5760320 1089 * @return BLE_ERROR_NONE if the disconnection procedure successfully
kenjiArai 0:5b88d5760320 1090 * started.
kenjiArai 0:5b88d5760320 1091 *
kenjiArai 0:5b88d5760320 1092 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1093 * GAP::disconnect(). A former call to
kenjiArai 0:5b88d5760320 1094 * ble.disconnect(...) should be replaced with
kenjiArai 0:5b88d5760320 1095 * ble.gap().disconnect(...).
kenjiArai 0:5b88d5760320 1096 */
kenjiArai 0:5b88d5760320 1097 MBED_DEPRECATED("Use ble.gap().disconnect(...)")
kenjiArai 0:5b88d5760320 1098 ble_error_t disconnect(Gap::Handle_t connectionHandle, Gap::DisconnectionReason_t reason);
kenjiArai 0:5b88d5760320 1099
kenjiArai 0:5b88d5760320 1100 /**
kenjiArai 0:5b88d5760320 1101 * This call initiates the disconnection procedure, and its completion
kenjiArai 0:5b88d5760320 1102 * is communicated to the application with an invocation of the
kenjiArai 0:5b88d5760320 1103 * onDisconnection callback.
kenjiArai 0:5b88d5760320 1104 *
kenjiArai 0:5b88d5760320 1105 * @param reason
kenjiArai 0:5b88d5760320 1106 * The reason for disconnection; sent back to the peer.
kenjiArai 0:5b88d5760320 1107 *
kenjiArai 0:5b88d5760320 1108 * @return BLE_ERROR_NONE if the disconnection procedure successfully
kenjiArai 0:5b88d5760320 1109 * started.
kenjiArai 0:5b88d5760320 1110 *
kenjiArai 0:5b88d5760320 1111 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1112 * Gap::disconnect(). A former call to
kenjiArai 0:5b88d5760320 1113 * ble.disconnect(reason) should be replaced with
kenjiArai 0:5b88d5760320 1114 * ble.gap().disconnect(reason).
kenjiArai 0:5b88d5760320 1115 *
kenjiArai 0:5b88d5760320 1116 * @note This version of disconnect() doesn't take a connection handle. It
kenjiArai 0:5b88d5760320 1117 * works reliably only for stacks that are limited to a single
kenjiArai 0:5b88d5760320 1118 * connection.
kenjiArai 0:5b88d5760320 1119 */
kenjiArai 0:5b88d5760320 1120 MBED_DEPRECATED("Use ble.gap().disconnect(...)")
kenjiArai 0:5b88d5760320 1121 ble_error_t disconnect(Gap::DisconnectionReason_t reason);
kenjiArai 0:5b88d5760320 1122 #endif // BLE_FEATURE_CONNECTABLE
kenjiArai 0:5b88d5760320 1123
kenjiArai 0:5b88d5760320 1124 /**
kenjiArai 0:5b88d5760320 1125 * Returns the current Gap state of the device using a bitmask that
kenjiArai 0:5b88d5760320 1126 * describes whether the device is advertising or connected.
kenjiArai 0:5b88d5760320 1127 *
kenjiArai 0:5b88d5760320 1128 * @return The current GAP state of the device.
kenjiArai 0:5b88d5760320 1129 *
kenjiArai 0:5b88d5760320 1130 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1131 * Gap::getState(). A former call to
kenjiArai 0:5b88d5760320 1132 * ble.getGapState() should be replaced with
kenjiArai 0:5b88d5760320 1133 * ble.gap().getState().
kenjiArai 0:5b88d5760320 1134 */
kenjiArai 0:5b88d5760320 1135 MBED_DEPRECATED("Use ble.gap().getState()")
kenjiArai 0:5b88d5760320 1136 Gap::GapState_t getGapState(void) const;
kenjiArai 0:5b88d5760320 1137
kenjiArai 0:5b88d5760320 1138 #if BLE_FEATURE_CONNECTABLE
kenjiArai 0:5b88d5760320 1139 #if BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1140 /**
kenjiArai 0:5b88d5760320 1141 * Get the GAP peripheral's preferred connection parameters. These are the
kenjiArai 0:5b88d5760320 1142 * defaults that the peripheral would like to have in a connection. The
kenjiArai 0:5b88d5760320 1143 * choice of the connection parameters is eventually up to the central.
kenjiArai 0:5b88d5760320 1144 *
kenjiArai 0:5b88d5760320 1145 * @param[out] params
kenjiArai 0:5b88d5760320 1146 * The structure where the parameters will be stored. The caller owns memory
kenjiArai 0:5b88d5760320 1147 * for this.
kenjiArai 0:5b88d5760320 1148 *
kenjiArai 0:5b88d5760320 1149 * @return BLE_ERROR_NONE if the parameters were successfully filled into
kenjiArai 0:5b88d5760320 1150 * the given structure pointed to by params.
kenjiArai 0:5b88d5760320 1151 *
kenjiArai 0:5b88d5760320 1152 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1153 * Gap::getPreferredConnectionParams(). A former call to
kenjiArai 0:5b88d5760320 1154 * ble.getPreferredConnectionParams() should be replaced with
kenjiArai 0:5b88d5760320 1155 * ble.gap().getPreferredConnectionParams().
kenjiArai 0:5b88d5760320 1156 */
kenjiArai 0:5b88d5760320 1157 MBED_DEPRECATED("Use ble.gap().getPreferredConnectionParams(...)")
kenjiArai 0:5b88d5760320 1158 ble_error_t getPreferredConnectionParams(Gap::ConnectionParams_t *params)
kenjiArai 0:5b88d5760320 1159 {
kenjiArai 0:5b88d5760320 1160 return gap().getPreferredConnectionParams(params);
kenjiArai 0:5b88d5760320 1161 }
kenjiArai 0:5b88d5760320 1162
kenjiArai 0:5b88d5760320 1163 /**
kenjiArai 0:5b88d5760320 1164 * Set the GAP peripheral's preferred connection parameters. These are the
kenjiArai 0:5b88d5760320 1165 * defaults that the peripheral would like to have in a connection. The
kenjiArai 0:5b88d5760320 1166 * choice of the connection parameters is eventually up to the central.
kenjiArai 0:5b88d5760320 1167 *
kenjiArai 0:5b88d5760320 1168 * @param[in] params
kenjiArai 0:5b88d5760320 1169 * The structure containing the desired parameters.
kenjiArai 0:5b88d5760320 1170 *
kenjiArai 0:5b88d5760320 1171 * @return BLE_ERROR_NONE if the preferred connection parameters were set
kenjiArai 0:5b88d5760320 1172 * correctly.
kenjiArai 0:5b88d5760320 1173 *
kenjiArai 0:5b88d5760320 1174 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1175 * Gap::setPreferredConnectionParams(). A former call to
kenjiArai 0:5b88d5760320 1176 * ble.setPreferredConnectionParams() should be replaced with
kenjiArai 0:5b88d5760320 1177 * ble.gap().setPreferredConnectionParams().
kenjiArai 0:5b88d5760320 1178 */
kenjiArai 0:5b88d5760320 1179 MBED_DEPRECATED("Use ble.gap().setPreferredConnectionParams(...)")
kenjiArai 0:5b88d5760320 1180 ble_error_t setPreferredConnectionParams(const Gap::ConnectionParams_t *params)
kenjiArai 0:5b88d5760320 1181 {
kenjiArai 0:5b88d5760320 1182 return gap().setPreferredConnectionParams(params);
kenjiArai 0:5b88d5760320 1183 }
kenjiArai 0:5b88d5760320 1184 #endif // BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1185
kenjiArai 0:5b88d5760320 1186 /**
kenjiArai 0:5b88d5760320 1187 * Update connection parameters while in the peripheral role.
kenjiArai 0:5b88d5760320 1188 *
kenjiArai 0:5b88d5760320 1189 * @details In the peripheral role, this will send the corresponding L2CAP request to the connected peer and wait for
kenjiArai 0:5b88d5760320 1190 * the central to perform the procedure.
kenjiArai 0:5b88d5760320 1191 *
kenjiArai 0:5b88d5760320 1192 * @param[in] handle
kenjiArai 0:5b88d5760320 1193 * Connection Handle
kenjiArai 0:5b88d5760320 1194 * @param[in] params
kenjiArai 0:5b88d5760320 1195 * Pointer to desired connection parameters. If NULL is provided on a peripheral role,
kenjiArai 0:5b88d5760320 1196 * the parameters in the PPCP characteristic of the GAP service will be used instead.
kenjiArai 0:5b88d5760320 1197 *
kenjiArai 0:5b88d5760320 1198 * @return BLE_ERROR_NONE if the connection parameters were updated correctly.
kenjiArai 0:5b88d5760320 1199 *
kenjiArai 0:5b88d5760320 1200 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1201 * Gap::updateConnectionParams(). A former call to
kenjiArai 0:5b88d5760320 1202 * ble.updateConnectionParams() should be replaced with
kenjiArai 0:5b88d5760320 1203 * ble.gap().updateConnectionParams().
kenjiArai 0:5b88d5760320 1204 */
kenjiArai 0:5b88d5760320 1205 MBED_DEPRECATED("Use ble.gap().updateConnectionParams(...)")
kenjiArai 0:5b88d5760320 1206 ble_error_t updateConnectionParams(Gap::Handle_t handle, const Gap::ConnectionParams_t *params);
kenjiArai 0:5b88d5760320 1207 #endif // BLE_FEATURE_CONNECTABLE
kenjiArai 0:5b88d5760320 1208
kenjiArai 0:5b88d5760320 1209 #if BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1210 /**
kenjiArai 0:5b88d5760320 1211 * Set the device name characteristic in the Gap service.
kenjiArai 0:5b88d5760320 1212 *
kenjiArai 0:5b88d5760320 1213 * @param[in] deviceName
kenjiArai 0:5b88d5760320 1214 * The new value for the device-name. This is a UTF-8 encoded, <b>NULL-terminated</b> string.
kenjiArai 0:5b88d5760320 1215 *
kenjiArai 0:5b88d5760320 1216 * @return BLE_ERROR_NONE if the device name was set correctly.
kenjiArai 0:5b88d5760320 1217 *
kenjiArai 0:5b88d5760320 1218 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1219 * Gap::setDeviceName(). A former call to
kenjiArai 0:5b88d5760320 1220 * ble.setDeviceName() should be replaced with
kenjiArai 0:5b88d5760320 1221 * ble.gap().setDeviceName().
kenjiArai 0:5b88d5760320 1222 */
kenjiArai 0:5b88d5760320 1223 MBED_DEPRECATED("Use ble.gap().setDeviceName(...)")
kenjiArai 0:5b88d5760320 1224 ble_error_t setDeviceName(const uint8_t *deviceName)
kenjiArai 0:5b88d5760320 1225 {
kenjiArai 0:5b88d5760320 1226 return gap().setDeviceName(deviceName);
kenjiArai 0:5b88d5760320 1227 }
kenjiArai 0:5b88d5760320 1228
kenjiArai 0:5b88d5760320 1229 /**
kenjiArai 0:5b88d5760320 1230 * Get the value of the device name characteristic in the Gap service.
kenjiArai 0:5b88d5760320 1231 *
kenjiArai 0:5b88d5760320 1232 * @param[out] deviceName
kenjiArai 0:5b88d5760320 1233 * Pointer to an empty buffer where the UTF-8 *non NULL-
kenjiArai 0:5b88d5760320 1234 * terminated* string will be placed. Set this
kenjiArai 0:5b88d5760320 1235 * value to NULL to obtain the deviceName-length
kenjiArai 0:5b88d5760320 1236 * from the 'length' parameter.
kenjiArai 0:5b88d5760320 1237 *
kenjiArai 0:5b88d5760320 1238 * @param[in,out] lengthP
kenjiArai 0:5b88d5760320 1239 * (on input) Length of the buffer pointed to by deviceName;
kenjiArai 0:5b88d5760320 1240 * (on output) the complete device name length (without the
kenjiArai 0:5b88d5760320 1241 * null terminator).
kenjiArai 0:5b88d5760320 1242 *
kenjiArai 0:5b88d5760320 1243 * @return BLE_ERROR_NONE if the device name was fetched correctly from the
kenjiArai 0:5b88d5760320 1244 * underlying BLE stack.
kenjiArai 0:5b88d5760320 1245 *
kenjiArai 0:5b88d5760320 1246 * @note If the device name is longer than the size of the supplied buffer,
kenjiArai 0:5b88d5760320 1247 * the length will return the complete device name length and not the
kenjiArai 0:5b88d5760320 1248 * number of bytes actually returned in deviceName. The application may
kenjiArai 0:5b88d5760320 1249 * use this information to retry with a suitable buffer size.
kenjiArai 0:5b88d5760320 1250 *
kenjiArai 0:5b88d5760320 1251 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1252 * Gap::getDeviceName(). A former call to
kenjiArai 0:5b88d5760320 1253 * ble.getDeviceName() should be replaced with
kenjiArai 0:5b88d5760320 1254 * ble.gap().getDeviceName().
kenjiArai 0:5b88d5760320 1255 */
kenjiArai 0:5b88d5760320 1256 MBED_DEPRECATED("Use ble.gap().getDeviceName(...)")
kenjiArai 0:5b88d5760320 1257 ble_error_t getDeviceName(uint8_t *deviceName, unsigned *lengthP)
kenjiArai 0:5b88d5760320 1258 {
kenjiArai 0:5b88d5760320 1259 return gap().getDeviceName(deviceName, lengthP);
kenjiArai 0:5b88d5760320 1260 }
kenjiArai 0:5b88d5760320 1261
kenjiArai 0:5b88d5760320 1262 /**
kenjiArai 0:5b88d5760320 1263 * Set the appearance characteristic in the Gap service.
kenjiArai 0:5b88d5760320 1264 *
kenjiArai 0:5b88d5760320 1265 * @param[in] appearance
kenjiArai 0:5b88d5760320 1266 * The new value for the device-appearance.
kenjiArai 0:5b88d5760320 1267 *
kenjiArai 0:5b88d5760320 1268 * @return BLE_ERROR_NONE if the new appearance was set correctly.
kenjiArai 0:5b88d5760320 1269 *
kenjiArai 0:5b88d5760320 1270 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1271 * Gap::setAppearance(). A former call to
kenjiArai 0:5b88d5760320 1272 * ble.setAppearance() should be replaced with
kenjiArai 0:5b88d5760320 1273 * ble.gap().setAppearance().
kenjiArai 0:5b88d5760320 1274 */
kenjiArai 0:5b88d5760320 1275 MBED_DEPRECATED("Use ble.gap().setAppearance(...)")
kenjiArai 0:5b88d5760320 1276 ble_error_t setAppearance(GapAdvertisingData::Appearance appearance)
kenjiArai 0:5b88d5760320 1277 {
kenjiArai 0:5b88d5760320 1278 return gap().setAppearance(appearance);
kenjiArai 0:5b88d5760320 1279 }
kenjiArai 0:5b88d5760320 1280
kenjiArai 0:5b88d5760320 1281 /**
kenjiArai 0:5b88d5760320 1282 * Get the appearance characteristic in the Gap service.
kenjiArai 0:5b88d5760320 1283 *
kenjiArai 0:5b88d5760320 1284 * @param[out] appearanceP
kenjiArai 0:5b88d5760320 1285 * The new value for the device-appearance.
kenjiArai 0:5b88d5760320 1286 *
kenjiArai 0:5b88d5760320 1287 * @return BLE_ERROR_NONE if the device-appearance was fetched correctly
kenjiArai 0:5b88d5760320 1288 * from the underlying BLE stack.
kenjiArai 0:5b88d5760320 1289 *
kenjiArai 0:5b88d5760320 1290 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 1291 * Gap::getAppearance(). A former call to
kenjiArai 0:5b88d5760320 1292 * ble.getAppearance() should be replaced with
kenjiArai 0:5b88d5760320 1293 * ble.gap().getAppearance().
kenjiArai 0:5b88d5760320 1294 */
kenjiArai 0:5b88d5760320 1295 MBED_DEPRECATED("Use ble.gap().getAppearance(...)")
kenjiArai 0:5b88d5760320 1296 ble_error_t getAppearance(GapAdvertisingData::Appearance *appearanceP)
kenjiArai 0:5b88d5760320 1297 {
kenjiArai 0:5b88d5760320 1298 return gap().getAppearance(appearanceP);
kenjiArai 0:5b88d5760320 1299 }
kenjiArai 0:5b88d5760320 1300 #endif // BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1301
kenjiArai 0:5b88d5760320 1302 /**
kenjiArai 0:5b88d5760320 1303 * Set the radio's transmit power.
kenjiArai 0:5b88d5760320 1304 *
kenjiArai 0:5b88d5760320 1305 * @param[in] txPower Radio transmit power in dBm.
kenjiArai 0:5b88d5760320 1306 *
kenjiArai 0:5b88d5760320 1307 * @return BLE_ERROR_NONE if the new radio's transmit power was set
kenjiArai 0:5b88d5760320 1308 * correctly.
kenjiArai 0:5b88d5760320 1309 *
kenjiArai 0:5b88d5760320 1310 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1311 * Gap::setTxPower(). A former call to
kenjiArai 0:5b88d5760320 1312 * ble.setTxPower() should be replaced with
kenjiArai 0:5b88d5760320 1313 * ble.gap().setTxPower().
kenjiArai 0:5b88d5760320 1314 */
kenjiArai 0:5b88d5760320 1315 MBED_DEPRECATED("Use ble.gap().setTxPower(...)")
kenjiArai 0:5b88d5760320 1316 ble_error_t setTxPower(int8_t txPower);
kenjiArai 0:5b88d5760320 1317
kenjiArai 0:5b88d5760320 1318 /**
kenjiArai 0:5b88d5760320 1319 * Query the underlying stack for permitted arguments for setTxPower().
kenjiArai 0:5b88d5760320 1320 *
kenjiArai 0:5b88d5760320 1321 * @param[out] valueArrayPP
kenjiArai 0:5b88d5760320 1322 * Out parameter to receive the immutable array of Tx values.
kenjiArai 0:5b88d5760320 1323 * @param[out] countP
kenjiArai 0:5b88d5760320 1324 * Out parameter to receive the array's size.
kenjiArai 0:5b88d5760320 1325 *
kenjiArai 0:5b88d5760320 1326 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 1327 * Gap::getPermittedTxPowerValues(). A former call to
kenjiArai 0:5b88d5760320 1328 * ble.getPermittedTxPowerValues() should be replaced with
kenjiArai 0:5b88d5760320 1329 * ble.gap().getPermittedTxPowerValues().
kenjiArai 0:5b88d5760320 1330 */
kenjiArai 0:5b88d5760320 1331 MBED_DEPRECATED("Use ble.gap().getPermittedTxPowerValues(...)")
kenjiArai 0:5b88d5760320 1332 void getPermittedTxPowerValues(const int8_t **valueArrayPP, size_t *countP);
kenjiArai 0:5b88d5760320 1333
kenjiArai 0:5b88d5760320 1334 #if BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1335 /**
kenjiArai 0:5b88d5760320 1336 * Add a service declaration to the local server ATT table. Also add the
kenjiArai 0:5b88d5760320 1337 * characteristics contained within.
kenjiArai 0:5b88d5760320 1338 *
kenjiArai 0:5b88d5760320 1339 * @param[in] service The service to be added; attribute handle of services,
kenjiArai 0:5b88d5760320 1340 * characteristic and characteristic descriptors are updated by the
kenjiArai 0:5b88d5760320 1341 * process.
kenjiArai 0:5b88d5760320 1342 *
kenjiArai 0:5b88d5760320 1343 * @return BLE_ERROR_NONE if the service was successfully added.
kenjiArai 0:5b88d5760320 1344 *
kenjiArai 0:5b88d5760320 1345 * @deprecated You should use the parallel API from GattServer directly, refer to
kenjiArai 0:5b88d5760320 1346 * GattServer::addService(). A former call
kenjiArai 0:5b88d5760320 1347 * to ble.addService() should be replaced with
kenjiArai 0:5b88d5760320 1348 * ble.gattServer().addService().
kenjiArai 0:5b88d5760320 1349 */
kenjiArai 0:5b88d5760320 1350 MBED_DEPRECATED("Use ble.gattServer().addService(...)")
kenjiArai 0:5b88d5760320 1351 ble_error_t addService(GattService &service)
kenjiArai 0:5b88d5760320 1352 {
kenjiArai 0:5b88d5760320 1353 return gattServer().addService(service);
kenjiArai 0:5b88d5760320 1354 }
kenjiArai 0:5b88d5760320 1355
kenjiArai 0:5b88d5760320 1356 /**
kenjiArai 0:5b88d5760320 1357 * Read the value of a characteristic from the local GattServer.
kenjiArai 0:5b88d5760320 1358 *
kenjiArai 0:5b88d5760320 1359 * @param[in] attributeHandle
kenjiArai 0:5b88d5760320 1360 * Attribute handle for the value attribute of the characteristic.
kenjiArai 0:5b88d5760320 1361 * @param[out] buffer
kenjiArai 0:5b88d5760320 1362 * A buffer to hold the value being read.
kenjiArai 0:5b88d5760320 1363 * @param[in,out] lengthP
kenjiArai 0:5b88d5760320 1364 * Length of the buffer being supplied. If the attribute
kenjiArai 0:5b88d5760320 1365 * value is longer than the size of the supplied buffer,
kenjiArai 0:5b88d5760320 1366 * this variable will return the total attribute value length
kenjiArai 0:5b88d5760320 1367 * (excluding offset). The application may use this
kenjiArai 0:5b88d5760320 1368 * information to allocate a suitable buffer size.
kenjiArai 0:5b88d5760320 1369 *
kenjiArai 0:5b88d5760320 1370 * @return BLE_ERROR_NONE if a value was read successfully into the buffer.
kenjiArai 0:5b88d5760320 1371 *
kenjiArai 0:5b88d5760320 1372 * @deprecated You should use the parallel API from GattServer directly,
kenjiArai 0:5b88d5760320 1373 * GattServer::read(GattAttribute::Handle_t,uint8_t,uint16_t). A former call
kenjiArai 0:5b88d5760320 1374 * to ble.readCharacteristicValue() should be replaced with
kenjiArai 0:5b88d5760320 1375 * ble.gattServer().read().
kenjiArai 0:5b88d5760320 1376 */
kenjiArai 0:5b88d5760320 1377 MBED_DEPRECATED("Use ble.gattServer().read(...)")
kenjiArai 0:5b88d5760320 1378 ble_error_t readCharacteristicValue(GattAttribute::Handle_t attributeHandle, uint8_t *buffer, uint16_t *lengthP)
kenjiArai 0:5b88d5760320 1379 {
kenjiArai 0:5b88d5760320 1380 return gattServer().read(attributeHandle, buffer, lengthP);
kenjiArai 0:5b88d5760320 1381 }
kenjiArai 0:5b88d5760320 1382
kenjiArai 0:5b88d5760320 1383 /**
kenjiArai 0:5b88d5760320 1384 * Read the value of a characteristic from the local GattServer.
kenjiArai 0:5b88d5760320 1385 *
kenjiArai 0:5b88d5760320 1386 * @param[in] connectionHandle
kenjiArai 0:5b88d5760320 1387 * Connection Handle.
kenjiArai 0:5b88d5760320 1388 * @param[in] attributeHandle
kenjiArai 0:5b88d5760320 1389 * Attribute handle for the value attribute of the characteristic.
kenjiArai 0:5b88d5760320 1390 * @param[out] buffer
kenjiArai 0:5b88d5760320 1391 * A buffer to hold the value being read.
kenjiArai 0:5b88d5760320 1392 * @param[in,out] lengthP
kenjiArai 0:5b88d5760320 1393 * Length of the buffer being supplied. If the attribute
kenjiArai 0:5b88d5760320 1394 * value is longer than the size of the supplied buffer,
kenjiArai 0:5b88d5760320 1395 * this variable will return the total attribute value length
kenjiArai 0:5b88d5760320 1396 * (excluding offset). The application may use this
kenjiArai 0:5b88d5760320 1397 * information to allocate a suitable buffer size.
kenjiArai 0:5b88d5760320 1398 *
kenjiArai 0:5b88d5760320 1399 * @return BLE_ERROR_NONE if a value was read successfully into the buffer.
kenjiArai 0:5b88d5760320 1400 *
kenjiArai 0:5b88d5760320 1401 * @note This API is a version of the above, with an additional connection handle
kenjiArai 0:5b88d5760320 1402 * parameter to allow fetches for connection-specific multivalued
kenjiArai 0:5b88d5760320 1403 * attributes (such as the CCCDs).
kenjiArai 0:5b88d5760320 1404 *
kenjiArai 0:5b88d5760320 1405 * @deprecated You should use the parallel API from GattServer directly, refer to
kenjiArai 0:5b88d5760320 1406 * GattServer::read(Gap::Handle_t,GattAttribute::Handle_t,uint8_t,uint16_t).
kenjiArai 0:5b88d5760320 1407 * A former call to ble.readCharacteristicValue() should be replaced with
kenjiArai 0:5b88d5760320 1408 * ble.gattServer().read().
kenjiArai 0:5b88d5760320 1409 */
kenjiArai 0:5b88d5760320 1410 MBED_DEPRECATED("Use ble.gattServer().read(...)")
kenjiArai 0:5b88d5760320 1411 ble_error_t readCharacteristicValue(
kenjiArai 0:5b88d5760320 1412 Gap::Handle_t connectionHandle,
kenjiArai 0:5b88d5760320 1413 GattAttribute::Handle_t attributeHandle,
kenjiArai 0:5b88d5760320 1414 uint8_t *buffer,
kenjiArai 0:5b88d5760320 1415 uint16_t *lengthP
kenjiArai 0:5b88d5760320 1416 )
kenjiArai 0:5b88d5760320 1417 {
kenjiArai 0:5b88d5760320 1418 return gattServer().read(connectionHandle, attributeHandle, buffer, lengthP);
kenjiArai 0:5b88d5760320 1419 }
kenjiArai 0:5b88d5760320 1420
kenjiArai 0:5b88d5760320 1421 /**
kenjiArai 0:5b88d5760320 1422 * Update the value of a characteristic on the local GattServer.
kenjiArai 0:5b88d5760320 1423 *
kenjiArai 0:5b88d5760320 1424 * @param[in] attributeHandle
kenjiArai 0:5b88d5760320 1425 * Handle for the value attribute of the characteristic.
kenjiArai 0:5b88d5760320 1426 * @param[in] value
kenjiArai 0:5b88d5760320 1427 * A pointer to a buffer holding the new value.
kenjiArai 0:5b88d5760320 1428 * @param[in] size
kenjiArai 0:5b88d5760320 1429 * Size of the new value (in bytes).
kenjiArai 0:5b88d5760320 1430 * @param[in] localOnly
kenjiArai 0:5b88d5760320 1431 * Should this update be kept on the local
kenjiArai 0:5b88d5760320 1432 * GattServer regardless of the state of the
kenjiArai 0:5b88d5760320 1433 * notify/indicate flag in the CCCD for this
kenjiArai 0:5b88d5760320 1434 * characteristic? If set to true, no notification
kenjiArai 0:5b88d5760320 1435 * or indication is generated.
kenjiArai 0:5b88d5760320 1436 *
kenjiArai 0:5b88d5760320 1437 * @return BLE_ERROR_NONE if we have successfully set the value of the attribute.
kenjiArai 0:5b88d5760320 1438 *
kenjiArai 0:5b88d5760320 1439 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1440 * GattServer::write(GattAttribute::Handle_t,const uint8_t,uint16_t,bool).
kenjiArai 0:5b88d5760320 1441 * A former call to ble.updateCharacteristicValue() should be replaced with
kenjiArai 0:5b88d5760320 1442 * ble.gattServer().write().
kenjiArai 0:5b88d5760320 1443 */
kenjiArai 0:5b88d5760320 1444 MBED_DEPRECATED("Use ble.gattServer().write(...)")
kenjiArai 0:5b88d5760320 1445 ble_error_t updateCharacteristicValue(
kenjiArai 0:5b88d5760320 1446 GattAttribute::Handle_t attributeHandle,
kenjiArai 0:5b88d5760320 1447 const uint8_t *value,
kenjiArai 0:5b88d5760320 1448 uint16_t size,
kenjiArai 0:5b88d5760320 1449 bool localOnly = false
kenjiArai 0:5b88d5760320 1450 )
kenjiArai 0:5b88d5760320 1451 {
kenjiArai 0:5b88d5760320 1452 return gattServer().write(attributeHandle, value, size, localOnly);
kenjiArai 0:5b88d5760320 1453 }
kenjiArai 0:5b88d5760320 1454
kenjiArai 0:5b88d5760320 1455 /**
kenjiArai 0:5b88d5760320 1456 * Update the value of a characteristic on the local GattServer. A version
kenjiArai 0:5b88d5760320 1457 * of the above, with a connection handle parameter to allow updates
kenjiArai 0:5b88d5760320 1458 * for connection-specific multivalued attributes (such as the CCCDs).
kenjiArai 0:5b88d5760320 1459 *
kenjiArai 0:5b88d5760320 1460 * @param[in] connectionHandle
kenjiArai 0:5b88d5760320 1461 * Connection Handle.
kenjiArai 0:5b88d5760320 1462 * @param[in] attributeHandle
kenjiArai 0:5b88d5760320 1463 * Handle for the value attribute of the Characteristic.
kenjiArai 0:5b88d5760320 1464 * @param[in] value
kenjiArai 0:5b88d5760320 1465 * A pointer to a buffer holding the new value.
kenjiArai 0:5b88d5760320 1466 * @param[in] size
kenjiArai 0:5b88d5760320 1467 * Size of the new value (in bytes).
kenjiArai 0:5b88d5760320 1468 * @param[in] localOnly
kenjiArai 0:5b88d5760320 1469 * Should this update be kept on the local
kenjiArai 0:5b88d5760320 1470 * GattServer regardless of the state of the
kenjiArai 0:5b88d5760320 1471 * notify/indicate flag in the CCCD for this
kenjiArai 0:5b88d5760320 1472 * Characteristic? If set to true, no notification
kenjiArai 0:5b88d5760320 1473 * or indication is generated.
kenjiArai 0:5b88d5760320 1474 *
kenjiArai 0:5b88d5760320 1475 * @return BLE_ERROR_NONE if we have successfully set the value of the attribute.
kenjiArai 0:5b88d5760320 1476 *
kenjiArai 0:5b88d5760320 1477 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1478 * GattServer::write(Gap::Handle_t,GattAttribute::Handle_t,const uint8_t,uint16_t,bool).
kenjiArai 0:5b88d5760320 1479 * A former call to ble.updateCharacteristicValue() should be replaced with
kenjiArai 0:5b88d5760320 1480 * ble.gattServer().write().
kenjiArai 0:5b88d5760320 1481 */
kenjiArai 0:5b88d5760320 1482 MBED_DEPRECATED("Use ble.gattServer().write(...)")
kenjiArai 0:5b88d5760320 1483 ble_error_t updateCharacteristicValue(
kenjiArai 0:5b88d5760320 1484 Gap::Handle_t connectionHandle,
kenjiArai 0:5b88d5760320 1485 GattAttribute::Handle_t attributeHandle,
kenjiArai 0:5b88d5760320 1486 const uint8_t *value,
kenjiArai 0:5b88d5760320 1487 uint16_t size,
kenjiArai 0:5b88d5760320 1488 bool localOnly = false
kenjiArai 0:5b88d5760320 1489 )
kenjiArai 0:5b88d5760320 1490 {
kenjiArai 0:5b88d5760320 1491 return gattServer().write(connectionHandle, attributeHandle, value, size, localOnly);
kenjiArai 0:5b88d5760320 1492 }
kenjiArai 0:5b88d5760320 1493 #endif // BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1494
kenjiArai 0:5b88d5760320 1495 #if BLE_FEATURE_SECURITY
kenjiArai 0:5b88d5760320 1496 /**
kenjiArai 0:5b88d5760320 1497 * Enable the BLE stack's Security Manager. The Security Manager implements
kenjiArai 0:5b88d5760320 1498 * the cryptographic algorithms and protocol exchanges that allow two
kenjiArai 0:5b88d5760320 1499 * devices to securely exchange data and privately detect each other.
kenjiArai 0:5b88d5760320 1500 * Calling this API is a prerequisite for encryption and pairing (bonding).
kenjiArai 0:5b88d5760320 1501 *
kenjiArai 0:5b88d5760320 1502 * @param[in] enableBonding Allow for bonding.
kenjiArai 0:5b88d5760320 1503 * @param[in] requireMITM Require protection against man-in-the-middle attacks.
kenjiArai 0:5b88d5760320 1504 * @param[in] iocaps To specify the I/O capabilities of this peripheral,
kenjiArai 0:5b88d5760320 1505 * such as availability of a display or keyboard, to
kenjiArai 0:5b88d5760320 1506 * support out-of-band exchanges of security data.
kenjiArai 0:5b88d5760320 1507 * @param[in] passkey To specify a static passkey.
kenjiArai 0:5b88d5760320 1508 *
kenjiArai 0:5b88d5760320 1509 * @return BLE_ERROR_NONE on success.
kenjiArai 0:5b88d5760320 1510 *
kenjiArai 0:5b88d5760320 1511 * @deprecated You should use the parallel API from SecurityManager directly, refer to
kenjiArai 0:5b88d5760320 1512 * SecurityManager.init(). A former
kenjiArai 0:5b88d5760320 1513 * call to ble.initializeSecurity(...) should be replaced with
kenjiArai 0:5b88d5760320 1514 * ble.securityManager().init(...).
kenjiArai 0:5b88d5760320 1515 */
kenjiArai 0:5b88d5760320 1516 MBED_DEPRECATED("Use ble.securityManager().init(...)")
kenjiArai 0:5b88d5760320 1517 ble_error_t initializeSecurity(
kenjiArai 0:5b88d5760320 1518 bool enableBonding = true,
kenjiArai 0:5b88d5760320 1519 bool requireMITM = true,
kenjiArai 0:5b88d5760320 1520 SecurityManager::SecurityIOCapabilities_t iocaps = SecurityManager::IO_CAPS_NONE,
kenjiArai 0:5b88d5760320 1521 const SecurityManager::Passkey_t passkey = NULL
kenjiArai 0:5b88d5760320 1522 )
kenjiArai 0:5b88d5760320 1523 {
kenjiArai 0:5b88d5760320 1524 return securityManager().init(enableBonding, requireMITM, iocaps, passkey);
kenjiArai 0:5b88d5760320 1525 }
kenjiArai 0:5b88d5760320 1526
kenjiArai 0:5b88d5760320 1527 /**
kenjiArai 0:5b88d5760320 1528 * Get the security status of a connection.
kenjiArai 0:5b88d5760320 1529 *
kenjiArai 0:5b88d5760320 1530 * @param[in] connectionHandle Handle to identify the connection.
kenjiArai 0:5b88d5760320 1531 * @param[out] securityStatusP Security status.
kenjiArai 0:5b88d5760320 1532 *
kenjiArai 0:5b88d5760320 1533 * @return BLE_SUCCESS or appropriate error code indicating the reason of failure.
kenjiArai 0:5b88d5760320 1534 *
kenjiArai 0:5b88d5760320 1535 * @deprecated You should use the parallel API from SecurityManager directly, refer to
kenjiArai 0:5b88d5760320 1536 * SecurityManager::getLinkSecurity(). A former
kenjiArai 0:5b88d5760320 1537 * call to ble.getLinkSecurity(...) should be replaced with
kenjiArai 0:5b88d5760320 1538 * ble.securityManager().getLinkSecurity(...).
kenjiArai 0:5b88d5760320 1539 */
kenjiArai 0:5b88d5760320 1540 MBED_DEPRECATED("ble.securityManager().getLinkSecurity(...)")
kenjiArai 0:5b88d5760320 1541 ble_error_t getLinkSecurity(Gap::Handle_t connectionHandle, SecurityManager::LinkSecurityStatus_t *securityStatusP)
kenjiArai 0:5b88d5760320 1542 {
kenjiArai 0:5b88d5760320 1543 return securityManager().getLinkSecurity(connectionHandle, securityStatusP);
kenjiArai 0:5b88d5760320 1544 }
kenjiArai 0:5b88d5760320 1545
kenjiArai 0:5b88d5760320 1546 /**
kenjiArai 0:5b88d5760320 1547 * Delete all peer device context and all related bonding information from
kenjiArai 0:5b88d5760320 1548 * the database within the security manager.
kenjiArai 0:5b88d5760320 1549 *
kenjiArai 0:5b88d5760320 1550 * @retval BLE_ERROR_NONE On success; else returns an error code indicating the reason for the failure.
kenjiArai 0:5b88d5760320 1551 * @retval BLE_ERROR_INVALID_STATE If the API is called without module initialization or
kenjiArai 0:5b88d5760320 1552 * application registration.
kenjiArai 0:5b88d5760320 1553 *
kenjiArai 0:5b88d5760320 1554 * @deprecated You should use the parallel API from SecurityManager directly and refer to
kenjiArai 0:5b88d5760320 1555 * SecurityManager::purgeAllBondingState(). A former
kenjiArai 0:5b88d5760320 1556 * call to ble.purgeAllBondingState() should be replaced with
kenjiArai 0:5b88d5760320 1557 * ble.securityManager().purgeAllBondingState().
kenjiArai 0:5b88d5760320 1558 */
kenjiArai 0:5b88d5760320 1559 MBED_DEPRECATED("ble.securityManager().purgeAllBondingState(...)")
kenjiArai 0:5b88d5760320 1560 ble_error_t purgeAllBondingState(void)
kenjiArai 0:5b88d5760320 1561 {
kenjiArai 0:5b88d5760320 1562 return securityManager().purgeAllBondingState();
kenjiArai 0:5b88d5760320 1563 }
kenjiArai 0:5b88d5760320 1564 #endif // BLE_FEATURE_SECURITY
kenjiArai 0:5b88d5760320 1565
kenjiArai 0:5b88d5760320 1566 /**
kenjiArai 0:5b88d5760320 1567 * Set up a callback for timeout events. Refer to Gap::TimeoutSource_t for
kenjiArai 0:5b88d5760320 1568 * possible event types.
kenjiArai 0:5b88d5760320 1569 *
kenjiArai 0:5b88d5760320 1570 * @param[in] timeoutCallback Event handler being registered.
kenjiArai 0:5b88d5760320 1571 *
kenjiArai 0:5b88d5760320 1572 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1573 * Gap::onTimeout(). A former call
kenjiArai 0:5b88d5760320 1574 * to ble.onTimeout(callback) should be replaced with
kenjiArai 0:5b88d5760320 1575 * ble.gap().onTimeout(callback).
kenjiArai 0:5b88d5760320 1576 */
kenjiArai 0:5b88d5760320 1577 MBED_DEPRECATED("ble.gap().onTimeout(callback)")
kenjiArai 0:5b88d5760320 1578 void onTimeout(Gap::TimeoutEventCallback_t timeoutCallback);
kenjiArai 0:5b88d5760320 1579
kenjiArai 0:5b88d5760320 1580 #if BLE_FEATURE_CONNECTABLE
kenjiArai 0:5b88d5760320 1581 /**
kenjiArai 0:5b88d5760320 1582 * Set up a callback for connection events. Refer to Gap::ConnectionEventCallback_t.
kenjiArai 0:5b88d5760320 1583 *
kenjiArai 0:5b88d5760320 1584 * @param[in] connectionCallback Event handler being registered.
kenjiArai 0:5b88d5760320 1585 *
kenjiArai 0:5b88d5760320 1586 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 1587 * Gap::onConnection(). A former call
kenjiArai 0:5b88d5760320 1588 * to ble.onConnection(callback) should be replaced with
kenjiArai 0:5b88d5760320 1589 * ble.gap().onConnection(callback).
kenjiArai 0:5b88d5760320 1590 */
kenjiArai 0:5b88d5760320 1591 MBED_DEPRECATED("ble.gap().onConnection(callback)")
kenjiArai 0:5b88d5760320 1592 void onConnection(Gap::ConnectionEventCallback_t connectionCallback);
kenjiArai 0:5b88d5760320 1593
kenjiArai 0:5b88d5760320 1594 /**
kenjiArai 0:5b88d5760320 1595 * Append to a chain of callbacks to be invoked upon GAP disconnection.
kenjiArai 0:5b88d5760320 1596 *
kenjiArai 0:5b88d5760320 1597 * @param[in] disconnectionCallback Event handler being registered.
kenjiArai 0:5b88d5760320 1598 *
kenjiArai 0:5b88d5760320 1599 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1600 * Gap::onDisconnection(). A former call
kenjiArai 0:5b88d5760320 1601 * to ble.onDisconnection(callback) should be replaced with
kenjiArai 0:5b88d5760320 1602 * ble.gap().onDisconnection(callback).
kenjiArai 0:5b88d5760320 1603 */
kenjiArai 0:5b88d5760320 1604 MBED_DEPRECATED("ble.gap().onDisconnectionComplete(callback)")
kenjiArai 0:5b88d5760320 1605 void onDisconnection(Gap::DisconnectionEventCallback_t disconnectionCallback);
kenjiArai 0:5b88d5760320 1606
kenjiArai 0:5b88d5760320 1607 /**
kenjiArai 0:5b88d5760320 1608 * The same as onDisconnection() but allows an object reference and member function
kenjiArai 0:5b88d5760320 1609 * to be added to the chain of callbacks.
kenjiArai 0:5b88d5760320 1610 *
kenjiArai 0:5b88d5760320 1611 * @param[in] tptr Instance used to invoke mptr.
kenjiArai 0:5b88d5760320 1612 * @param[in] mptr Event handler being registered.
kenjiArai 0:5b88d5760320 1613 *
kenjiArai 0:5b88d5760320 1614 * @deprecated You should use the parallel API from Gap directly and refer to
kenjiArai 0:5b88d5760320 1615 * Gap::onDisconnection(). A former call
kenjiArai 0:5b88d5760320 1616 * to ble.onDisconnection(callback) should be replaced with
kenjiArai 0:5b88d5760320 1617 * ble.gap().onDisconnection(callback).
kenjiArai 0:5b88d5760320 1618 */
kenjiArai 0:5b88d5760320 1619 template<typename T>
kenjiArai 0:5b88d5760320 1620 MBED_DEPRECATED("ble.gap().onDisconnectionComplete(callback)")
kenjiArai 0:5b88d5760320 1621 void onDisconnection(T *tptr, void (T::*mptr)(const Gap::DisconnectionCallbackParams_t *))
kenjiArai 0:5b88d5760320 1622 {
kenjiArai 0:5b88d5760320 1623 gap().onDisconnection(tptr, mptr);
kenjiArai 0:5b88d5760320 1624 }
kenjiArai 0:5b88d5760320 1625 #endif // BLE_FEATURE_CONNECTABLE
kenjiArai 0:5b88d5760320 1626
kenjiArai 0:5b88d5760320 1627 /**
kenjiArai 0:5b88d5760320 1628 * Radio Notification is a feature that enables ACTIVE and INACTIVE
kenjiArai 0:5b88d5760320 1629 * (nACTIVE) signals from the stack. These notify the application when the
kenjiArai 0:5b88d5760320 1630 * radio is in use. The signal is sent using software interrupt.
kenjiArai 0:5b88d5760320 1631 *
kenjiArai 0:5b88d5760320 1632 * The ACTIVE signal is sent before the radio event starts. The nACTIVE
kenjiArai 0:5b88d5760320 1633 * signal is sent at the end of the radio event. These signals can be used
kenjiArai 0:5b88d5760320 1634 * by the application programmer to synchronize application logic with radio
kenjiArai 0:5b88d5760320 1635 * activity. For example, the ACTIVE signal can be used to shut off external
kenjiArai 0:5b88d5760320 1636 * devices to manage peak current drawn during periods when the radio is on,
kenjiArai 0:5b88d5760320 1637 * or to trigger sensor data collection for transmission in the radio event.
kenjiArai 0:5b88d5760320 1638 *
kenjiArai 0:5b88d5760320 1639 * @param callback
kenjiArai 0:5b88d5760320 1640 * The application handler to be invoked in response to a radio
kenjiArai 0:5b88d5760320 1641 * ACTIVE/INACTIVE event.
kenjiArai 0:5b88d5760320 1642 *
kenjiArai 0:5b88d5760320 1643 * @deprecated You should use the parallel API from Gap directly, refer to
kenjiArai 0:5b88d5760320 1644 * Gap::onRadioNotification(). A former call
kenjiArai 0:5b88d5760320 1645 * to ble.onRadioNotification(...) should be replaced with
kenjiArai 0:5b88d5760320 1646 * ble.gap().onRadioNotification(...).
kenjiArai 0:5b88d5760320 1647 */
kenjiArai 0:5b88d5760320 1648 MBED_DEPRECATED("ble.gap().onRadioNotification(...)")
kenjiArai 0:5b88d5760320 1649 void onRadioNotification(void (*callback)(bool));
kenjiArai 0:5b88d5760320 1650
kenjiArai 0:5b88d5760320 1651 #if BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1652 /**
kenjiArai 0:5b88d5760320 1653 * Add a callback for the GATT event DATA_SENT (which is triggered when
kenjiArai 0:5b88d5760320 1654 * updates are sent out by GATT in the form of notifications).
kenjiArai 0:5b88d5760320 1655 *
kenjiArai 0:5b88d5760320 1656 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1657 *
kenjiArai 0:5b88d5760320 1658 * @note It is possible to chain together multiple onDataSent callbacks
kenjiArai 0:5b88d5760320 1659 * (potentially from different modules of an application) to receive updates
kenjiArai 0:5b88d5760320 1660 * to characteristics.
kenjiArai 0:5b88d5760320 1661 *
kenjiArai 0:5b88d5760320 1662 * @note It is also possible to set up a callback into a member function of
kenjiArai 0:5b88d5760320 1663 * some object.
kenjiArai 0:5b88d5760320 1664 *
kenjiArai 0:5b88d5760320 1665 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1666 * GattServer::onDataSent(). A former call
kenjiArai 0:5b88d5760320 1667 * to ble.onDataSent(...) should be replaced with
kenjiArai 0:5b88d5760320 1668 * ble.gattServer().onDataSent(...).
kenjiArai 0:5b88d5760320 1669 */
kenjiArai 0:5b88d5760320 1670 MBED_DEPRECATED("ble.gattServer().onDataSent(...)")
kenjiArai 0:5b88d5760320 1671 void onDataSent(void (*callback)(unsigned count))
kenjiArai 0:5b88d5760320 1672 {
kenjiArai 0:5b88d5760320 1673 gattServer().onDataSent(callback);
kenjiArai 0:5b88d5760320 1674 }
kenjiArai 0:5b88d5760320 1675
kenjiArai 0:5b88d5760320 1676 /**
kenjiArai 0:5b88d5760320 1677 * The same as onDataSent() but allows an object reference and member function
kenjiArai 0:5b88d5760320 1678 * to be added to the chain of callbacks.
kenjiArai 0:5b88d5760320 1679 *
kenjiArai 0:5b88d5760320 1680 * @param[in] objPtr Pointer to the instance that is used to invoke the
kenjiArai 0:5b88d5760320 1681 * event handler.
kenjiArai 0:5b88d5760320 1682 * @param[in] memberPtr Event handler being registered. It is a member
kenjiArai 0:5b88d5760320 1683 * function.
kenjiArai 0:5b88d5760320 1684 *
kenjiArai 0:5b88d5760320 1685 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1686 * GattServer::onDataSent(). A former call
kenjiArai 0:5b88d5760320 1687 * to ble.onDataSent(...) should be replaced with
kenjiArai 0:5b88d5760320 1688 * ble.gattServer().onDataSent(...).
kenjiArai 0:5b88d5760320 1689 */
kenjiArai 0:5b88d5760320 1690 template<typename T>
kenjiArai 0:5b88d5760320 1691 MBED_DEPRECATED("ble.gattServer().onDataSent(...)")
kenjiArai 0:5b88d5760320 1692 void onDataSent(T *objPtr, void (T::*memberPtr)(unsigned count))
kenjiArai 0:5b88d5760320 1693 {
kenjiArai 0:5b88d5760320 1694 gattServer().onDataSent(objPtr, memberPtr);
kenjiArai 0:5b88d5760320 1695 }
kenjiArai 0:5b88d5760320 1696
kenjiArai 0:5b88d5760320 1697 /**
kenjiArai 0:5b88d5760320 1698 * Set up a callback for when an attribute has its value updated by or at the
kenjiArai 0:5b88d5760320 1699 * connected peer. For a peripheral, this callback is triggered when the local
kenjiArai 0:5b88d5760320 1700 * GATT server has an attribute updated by a write command from the peer.
kenjiArai 0:5b88d5760320 1701 * For a Central, this callback is triggered when a response is received for
kenjiArai 0:5b88d5760320 1702 * a write request.
kenjiArai 0:5b88d5760320 1703 *
kenjiArai 0:5b88d5760320 1704 * @param[in] callback The event handler being registered.
kenjiArai 0:5b88d5760320 1705 *
kenjiArai 0:5b88d5760320 1706 * @note It is possible to chain together multiple onDataWritten callbacks
kenjiArai 0:5b88d5760320 1707 * (potentially from different modules of an application) to receive updates
kenjiArai 0:5b88d5760320 1708 * to characteristics. Many services, such as DFU and UART, add their own
kenjiArai 0:5b88d5760320 1709 * onDataWritten callbacks behind the scenes to trap interesting events.
kenjiArai 0:5b88d5760320 1710 *
kenjiArai 0:5b88d5760320 1711 * @note It is also possible to set up a callback into a member function of
kenjiArai 0:5b88d5760320 1712 * some object.
kenjiArai 0:5b88d5760320 1713 *
kenjiArai 0:5b88d5760320 1714 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1715 * GattServer::onDataWritten(). A former call
kenjiArai 0:5b88d5760320 1716 * to ble.onDataWritten(...) should be replaced with
kenjiArai 0:5b88d5760320 1717 * ble.gattServer().onDataWritten(...).
kenjiArai 0:5b88d5760320 1718 */
kenjiArai 0:5b88d5760320 1719 MBED_DEPRECATED("ble.gattServer().onDataWritten(...)")
kenjiArai 0:5b88d5760320 1720 void onDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP))
kenjiArai 0:5b88d5760320 1721 {
kenjiArai 0:5b88d5760320 1722 gattServer().onDataWritten(callback);
kenjiArai 0:5b88d5760320 1723 }
kenjiArai 0:5b88d5760320 1724
kenjiArai 0:5b88d5760320 1725 /**
kenjiArai 0:5b88d5760320 1726 * The same as onDataWritten() but allows an object reference and member function
kenjiArai 0:5b88d5760320 1727 * to be added to the chain of callbacks.
kenjiArai 0:5b88d5760320 1728 *
kenjiArai 0:5b88d5760320 1729 * @param[in] objPtr Pointer to the instance that is used to invoke the
kenjiArai 0:5b88d5760320 1730 * event handler (@p memberPtr).
kenjiArai 0:5b88d5760320 1731 * @param[in] memberPtr Event handler being registered. It is a member
kenjiArai 0:5b88d5760320 1732 * function.
kenjiArai 0:5b88d5760320 1733 *
kenjiArai 0:5b88d5760320 1734 *
kenjiArai 0:5b88d5760320 1735 * @deprecated You should use the parallel API from GattServer directly, refer to
kenjiArai 0:5b88d5760320 1736 * GattServer::onDataWritten(). A former call
kenjiArai 0:5b88d5760320 1737 * to ble.onDataWritten(...) should be replaced with
kenjiArai 0:5b88d5760320 1738 * ble.gattServer().onDataWritten(...).
kenjiArai 0:5b88d5760320 1739 */
kenjiArai 0:5b88d5760320 1740 template<typename T>
kenjiArai 0:5b88d5760320 1741 MBED_DEPRECATED("ble.gattServer().onDataWritten(...)")
kenjiArai 0:5b88d5760320 1742 void onDataWritten(T *objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context))
kenjiArai 0:5b88d5760320 1743 {
kenjiArai 0:5b88d5760320 1744 gattServer().onDataWritten(objPtr, memberPtr);
kenjiArai 0:5b88d5760320 1745 }
kenjiArai 0:5b88d5760320 1746
kenjiArai 0:5b88d5760320 1747 /**
kenjiArai 0:5b88d5760320 1748 * Set up a callback to be invoked on the peripheral when an attribute is
kenjiArai 0:5b88d5760320 1749 * being read by a remote client.
kenjiArai 0:5b88d5760320 1750 *
kenjiArai 0:5b88d5760320 1751 * @note This functionality may not be available on all underlying stacks.
kenjiArai 0:5b88d5760320 1752 * You could use GattCharacteristic::setReadAuthorizationCallback() as an
kenjiArai 0:5b88d5760320 1753 * alternative.
kenjiArai 0:5b88d5760320 1754 *
kenjiArai 0:5b88d5760320 1755 * @note It is possible to chain together multiple onDataRead callbacks
kenjiArai 0:5b88d5760320 1756 * (potentially from different modules of an application) to receive updates
kenjiArai 0:5b88d5760320 1757 * to characteristics. Services may add their own onDataRead callbacks
kenjiArai 0:5b88d5760320 1758 * behind the scenes to trap interesting events.
kenjiArai 0:5b88d5760320 1759 *
kenjiArai 0:5b88d5760320 1760 * @note It is also possible to set up a callback into a member function of
kenjiArai 0:5b88d5760320 1761 * some object.
kenjiArai 0:5b88d5760320 1762 *
kenjiArai 0:5b88d5760320 1763 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1764 *
kenjiArai 0:5b88d5760320 1765 * @return BLE_ERROR_NOT_IMPLEMENTED if this functionality isn't available;
kenjiArai 0:5b88d5760320 1766 * else BLE_ERROR_NONE.
kenjiArai 0:5b88d5760320 1767 *
kenjiArai 0:5b88d5760320 1768 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1769 * GattServer::onDataRead(). A former call
kenjiArai 0:5b88d5760320 1770 * to ble.onDataRead(...) should be replaced with
kenjiArai 0:5b88d5760320 1771 * ble.gattServer().onDataRead(...).
kenjiArai 0:5b88d5760320 1772 */
kenjiArai 0:5b88d5760320 1773 MBED_DEPRECATED("ble.gattServer().onDataRead(...)")
kenjiArai 0:5b88d5760320 1774 ble_error_t onDataRead(void (*callback)(const GattReadCallbackParams *eventDataP))
kenjiArai 0:5b88d5760320 1775 {
kenjiArai 0:5b88d5760320 1776 return gattServer().onDataRead(callback);
kenjiArai 0:5b88d5760320 1777 }
kenjiArai 0:5b88d5760320 1778
kenjiArai 0:5b88d5760320 1779 /**
kenjiArai 0:5b88d5760320 1780 * The same as onDataRead() but allows an object reference and member function
kenjiArai 0:5b88d5760320 1781 * to be added to the chain of callbacks.
kenjiArai 0:5b88d5760320 1782 *
kenjiArai 0:5b88d5760320 1783 * @param[in] objPtr Pointer to the instance that is used to invoke the
kenjiArai 0:5b88d5760320 1784 * event handler (@p memberPtr).
kenjiArai 0:5b88d5760320 1785 * @param[in] memberPtr Event handler being registered. It is a member
kenjiArai 0:5b88d5760320 1786 * function.
kenjiArai 0:5b88d5760320 1787 *
kenjiArai 0:5b88d5760320 1788 * @return BLE_ERROR_NOT_IMPLEMENTED if this functionality isn't available;
kenjiArai 0:5b88d5760320 1789 * else BLE_ERROR_NONE.
kenjiArai 0:5b88d5760320 1790 *
kenjiArai 0:5b88d5760320 1791 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1792 * GattServer::onDataRead(). A former call
kenjiArai 0:5b88d5760320 1793 * to ble.onDataRead(...) should be replaced with
kenjiArai 0:5b88d5760320 1794 * ble.gattServer().onDataRead(...).
kenjiArai 0:5b88d5760320 1795 */
kenjiArai 0:5b88d5760320 1796 template<typename T>
kenjiArai 0:5b88d5760320 1797 MBED_DEPRECATED("ble.gattServer().onDataRead(...)")
kenjiArai 0:5b88d5760320 1798 ble_error_t onDataRead(T *objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context))
kenjiArai 0:5b88d5760320 1799 {
kenjiArai 0:5b88d5760320 1800 return gattServer().onDataRead(objPtr, memberPtr);
kenjiArai 0:5b88d5760320 1801 }
kenjiArai 0:5b88d5760320 1802
kenjiArai 0:5b88d5760320 1803 /**
kenjiArai 0:5b88d5760320 1804 * Set up a callback for when notifications or indications are enabled for a
kenjiArai 0:5b88d5760320 1805 * characteristic on the local GattServer.
kenjiArai 0:5b88d5760320 1806 *
kenjiArai 0:5b88d5760320 1807 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1808 *
kenjiArai 0:5b88d5760320 1809 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1810 * GattServer::onUpdatesEnabled(). A former call
kenjiArai 0:5b88d5760320 1811 * to ble.onUpdatesEnabled(callback) should be replaced with
kenjiArai 0:5b88d5760320 1812 * ble.gattServer().onUpdatesEnabled(callback).
kenjiArai 0:5b88d5760320 1813 */
kenjiArai 0:5b88d5760320 1814 MBED_DEPRECATED("ble.gattServer().onUpdatesEnabled(...)")
kenjiArai 0:5b88d5760320 1815 void onUpdatesEnabled(GattServer::EventCallback_t callback)
kenjiArai 0:5b88d5760320 1816 {
kenjiArai 0:5b88d5760320 1817 gattServer().onUpdatesEnabled(callback);
kenjiArai 0:5b88d5760320 1818 }
kenjiArai 0:5b88d5760320 1819
kenjiArai 0:5b88d5760320 1820 /**
kenjiArai 0:5b88d5760320 1821 * Set up a callback for when notifications or indications are disabled for a
kenjiArai 0:5b88d5760320 1822 * characteristic on the local GattServer.
kenjiArai 0:5b88d5760320 1823 *
kenjiArai 0:5b88d5760320 1824 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1825 *
kenjiArai 0:5b88d5760320 1826 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1827 * GattServer::onUpdatesDisabled(). A former call
kenjiArai 0:5b88d5760320 1828 * to ble.onUpdatesDisabled(callback) should be replaced with
kenjiArai 0:5b88d5760320 1829 * ble.gattServer().onUpdatesDisabled(callback).
kenjiArai 0:5b88d5760320 1830 */
kenjiArai 0:5b88d5760320 1831 MBED_DEPRECATED("ble.gattServer().onUpdatesDisabled(...)")
kenjiArai 0:5b88d5760320 1832 void onUpdatesDisabled(GattServer::EventCallback_t callback)
kenjiArai 0:5b88d5760320 1833 {
kenjiArai 0:5b88d5760320 1834 gattServer().onUpdatesDisabled(callback);
kenjiArai 0:5b88d5760320 1835 }
kenjiArai 0:5b88d5760320 1836
kenjiArai 0:5b88d5760320 1837 /**
kenjiArai 0:5b88d5760320 1838 * Set up a callback for when the GATT server receives a response for an
kenjiArai 0:5b88d5760320 1839 * indication event sent previously.
kenjiArai 0:5b88d5760320 1840 *
kenjiArai 0:5b88d5760320 1841 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1842 *
kenjiArai 0:5b88d5760320 1843 * @deprecated You should use the parallel API from GattServer directly and refer to
kenjiArai 0:5b88d5760320 1844 * GattServer::onConfirmationReceived(). A former call
kenjiArai 0:5b88d5760320 1845 * to ble.onConfirmationReceived(callback) should be replaced with
kenjiArai 0:5b88d5760320 1846 * ble.gattServer().onConfirmationReceived(callback).
kenjiArai 0:5b88d5760320 1847 */
kenjiArai 0:5b88d5760320 1848 MBED_DEPRECATED("ble.gattServer().onConfirmationReceived(...)")
kenjiArai 0:5b88d5760320 1849 void onConfirmationReceived(GattServer::EventCallback_t callback)
kenjiArai 0:5b88d5760320 1850 {
kenjiArai 0:5b88d5760320 1851 gattServer().onConfirmationReceived(callback);
kenjiArai 0:5b88d5760320 1852 }
kenjiArai 0:5b88d5760320 1853 #endif // BLE_FEATURE_GATT_SERVER
kenjiArai 0:5b88d5760320 1854
kenjiArai 0:5b88d5760320 1855 #if BLE_FEATURE_SECURITY
kenjiArai 0:5b88d5760320 1856 /**
kenjiArai 0:5b88d5760320 1857 * Set up a callback for when the security setup procedure (key generation
kenjiArai 0:5b88d5760320 1858 * and exchange) for a link has started. This will be skipped for bonded
kenjiArai 0:5b88d5760320 1859 * devices. The callback is passed in parameters received from the peer's
kenjiArai 0:5b88d5760320 1860 * security request: bool allowBonding, bool requireMITM and
kenjiArai 0:5b88d5760320 1861 * SecurityIOCapabilities_t.
kenjiArai 0:5b88d5760320 1862 *
kenjiArai 0:5b88d5760320 1863 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1864 *
kenjiArai 0:5b88d5760320 1865 * @deprecated You should use the parallel API from SecurityManager directly and refer to
kenjiArai 0:5b88d5760320 1866 * SecurityManager::onSecuritySetupInitiated(). A former
kenjiArai 0:5b88d5760320 1867 * call to ble.onSecuritySetupInitiated(callback) should be replaced with
kenjiArai 0:5b88d5760320 1868 * ble.securityManager().onSecuritySetupInitiated(callback).
kenjiArai 0:5b88d5760320 1869 */
kenjiArai 0:5b88d5760320 1870 MBED_DEPRECATED("ble.securityManager().onSecuritySetupInitiated(callback)")
kenjiArai 0:5b88d5760320 1871 void onSecuritySetupInitiated(SecurityManager::SecuritySetupInitiatedCallback_t callback)
kenjiArai 0:5b88d5760320 1872 {
kenjiArai 0:5b88d5760320 1873 securityManager().onSecuritySetupInitiated(callback);
kenjiArai 0:5b88d5760320 1874 }
kenjiArai 0:5b88d5760320 1875
kenjiArai 0:5b88d5760320 1876 /**
kenjiArai 0:5b88d5760320 1877 * Set up a callback for when the security setup procedure (key generation
kenjiArai 0:5b88d5760320 1878 * and exchange) for a link has completed. This will be skipped for bonded
kenjiArai 0:5b88d5760320 1879 * devices. The callback is passed in the success/failure status of the
kenjiArai 0:5b88d5760320 1880 * security setup procedure.
kenjiArai 0:5b88d5760320 1881 *
kenjiArai 0:5b88d5760320 1882 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1883 *
kenjiArai 0:5b88d5760320 1884 * @deprecated You should use the parallel API from SecurityManager directly and refer to
kenjiArai 0:5b88d5760320 1885 * SecurityManager::onSecuritySetupCompleted(). A former
kenjiArai 0:5b88d5760320 1886 * call to ble.onSecuritySetupCompleted(callback) should be replaced with
kenjiArai 0:5b88d5760320 1887 * ble.securityManager().onSecuritySetupCompleted(callback).
kenjiArai 0:5b88d5760320 1888 */
kenjiArai 0:5b88d5760320 1889 MBED_DEPRECATED("ble.securityManager().onSecuritySetupCompleted(callback)")
kenjiArai 0:5b88d5760320 1890 void onSecuritySetupCompleted(SecurityManager::SecuritySetupCompletedCallback_t callback)
kenjiArai 0:5b88d5760320 1891 {
kenjiArai 0:5b88d5760320 1892 securityManager().onSecuritySetupCompleted(callback);
kenjiArai 0:5b88d5760320 1893 }
kenjiArai 0:5b88d5760320 1894
kenjiArai 0:5b88d5760320 1895 /**
kenjiArai 0:5b88d5760320 1896 * Set up a callback for when a link with the peer is secured. For bonded
kenjiArai 0:5b88d5760320 1897 * devices, subsequent reconnections with a bonded peer will result only in
kenjiArai 0:5b88d5760320 1898 * this callback when the link is secured, and setup procedures will not
kenjiArai 0:5b88d5760320 1899 * occur unless the bonding information is either lost or deleted on either
kenjiArai 0:5b88d5760320 1900 * or both sides. The callback is passed in a SecurityManager::SecurityMode_t according
kenjiArai 0:5b88d5760320 1901 * to the level of security in effect for the secured link.
kenjiArai 0:5b88d5760320 1902 *
kenjiArai 0:5b88d5760320 1903 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1904 *
kenjiArai 0:5b88d5760320 1905 * @deprecated You should use the parallel API from SecurityManager directly and refer to
kenjiArai 0:5b88d5760320 1906 * SecurityManager::onLinkSecured(). A former
kenjiArai 0:5b88d5760320 1907 * call to ble.onLinkSecured(callback) should be replaced with
kenjiArai 0:5b88d5760320 1908 * ble.securityManager().onLinkSecured(callback).
kenjiArai 0:5b88d5760320 1909 */
kenjiArai 0:5b88d5760320 1910 MBED_DEPRECATED("ble.securityManager().onLinkSecured(callback)")
kenjiArai 0:5b88d5760320 1911 void onLinkSecured(SecurityManager::LinkSecuredCallback_t callback)
kenjiArai 0:5b88d5760320 1912 {
kenjiArai 0:5b88d5760320 1913 securityManager().onLinkSecured(callback);
kenjiArai 0:5b88d5760320 1914 }
kenjiArai 0:5b88d5760320 1915
kenjiArai 0:5b88d5760320 1916 /**
kenjiArai 0:5b88d5760320 1917 * Set up a callback for successful bonding, meaning that link-specific security
kenjiArai 0:5b88d5760320 1918 * context is stored persistently for a peer device.
kenjiArai 0:5b88d5760320 1919 *
kenjiArai 0:5b88d5760320 1920 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1921 *
kenjiArai 0:5b88d5760320 1922 * @deprecated You should use the parallel API from SecurityManager directly and refer to
kenjiArai 0:5b88d5760320 1923 * SecurityManager::onSecurityContextStored(). A former
kenjiArai 0:5b88d5760320 1924 * call to ble.onSecurityContextStored(callback) should be replaced with
kenjiArai 0:5b88d5760320 1925 * ble.securityManager().onSecurityContextStored(callback).
kenjiArai 0:5b88d5760320 1926 */
kenjiArai 0:5b88d5760320 1927 MBED_DEPRECATED("ble.securityManager().onSecurityContextStored(callback)")
kenjiArai 0:5b88d5760320 1928 void onSecurityContextStored(SecurityManager::HandleSpecificEvent_t callback)
kenjiArai 0:5b88d5760320 1929 {
kenjiArai 0:5b88d5760320 1930 securityManager().onSecurityContextStored(callback);
kenjiArai 0:5b88d5760320 1931 }
kenjiArai 0:5b88d5760320 1932
kenjiArai 0:5b88d5760320 1933 /**
kenjiArai 0:5b88d5760320 1934 * Set up a callback for when the passkey needs to be displayed on a
kenjiArai 0:5b88d5760320 1935 * peripheral with DISPLAY capability. This happens when security is
kenjiArai 0:5b88d5760320 1936 * configured to prevent man-in-the-middle attacks, and the peers need to exchange
kenjiArai 0:5b88d5760320 1937 * a passkey (or PIN) to authenticate the connection
kenjiArai 0:5b88d5760320 1938 * attempt.
kenjiArai 0:5b88d5760320 1939 *
kenjiArai 0:5b88d5760320 1940 * @param[in] callback Event handler being registered.
kenjiArai 0:5b88d5760320 1941 *
kenjiArai 0:5b88d5760320 1942 * @deprecated You should use the parallel API from SecurityManager directly and refer to
kenjiArai 0:5b88d5760320 1943 * SecurityManager::onPasskeyDisplay(). A former
kenjiArai 0:5b88d5760320 1944 * call to ble.onPasskeyDisplay(callback) should be replaced with
kenjiArai 0:5b88d5760320 1945 * ble.securityManager().onPasskeyDisplay(callback).
kenjiArai 0:5b88d5760320 1946 */
kenjiArai 0:5b88d5760320 1947 MBED_DEPRECATED("ble.securityManager().onPasskeyDisplay(callback)")
kenjiArai 0:5b88d5760320 1948 void onPasskeyDisplay(SecurityManager::PasskeyDisplayCallback_t callback)
kenjiArai 0:5b88d5760320 1949 {
kenjiArai 0:5b88d5760320 1950 return securityManager().onPasskeyDisplay(callback);
kenjiArai 0:5b88d5760320 1951 }
kenjiArai 0:5b88d5760320 1952 #endif // BLE_FEATURE_SECURITY
kenjiArai 0:5b88d5760320 1953
kenjiArai 0:5b88d5760320 1954 private:
kenjiArai 0:5b88d5760320 1955 friend class BLEInstanceBase;
kenjiArai 0:5b88d5760320 1956
kenjiArai 0:5b88d5760320 1957 /**
kenjiArai 0:5b88d5760320 1958 * This function allows the BLE stack to signal that there is work to do and
kenjiArai 0:5b88d5760320 1959 * event processing should be done (BLE::processEvent()).
kenjiArai 0:5b88d5760320 1960 *
kenjiArai 0:5b88d5760320 1961 * @note This function should be called by the port of BLE_API. It is not
kenjiArai 0:5b88d5760320 1962 * meant to be used by end users.
kenjiArai 0:5b88d5760320 1963 */
kenjiArai 0:5b88d5760320 1964 void signalEventsToProcess();
kenjiArai 0:5b88d5760320 1965
kenjiArai 0:5b88d5760320 1966 /**
kenjiArai 0:5b88d5760320 1967 * Implementation of init() [internal to BLE_API].
kenjiArai 0:5b88d5760320 1968 *
kenjiArai 0:5b88d5760320 1969 * The implementation is separated into a private method because it isn't
kenjiArai 0:5b88d5760320 1970 * suitable to be included in the header.
kenjiArai 0:5b88d5760320 1971 */
kenjiArai 0:5b88d5760320 1972 ble_error_t initImplementation(
kenjiArai 0:5b88d5760320 1973 FunctionPointerWithContext<InitializationCompleteCallbackContext *> callback
kenjiArai 0:5b88d5760320 1974 );
kenjiArai 0:5b88d5760320 1975
kenjiArai 0:5b88d5760320 1976 private:
kenjiArai 0:5b88d5760320 1977 // Prevent copy construction and copy assignment of BLE.
kenjiArai 0:5b88d5760320 1978 BLE(const BLE &);
kenjiArai 0:5b88d5760320 1979
kenjiArai 0:5b88d5760320 1980 BLE &operator=(const BLE &);
kenjiArai 0:5b88d5760320 1981
kenjiArai 0:5b88d5760320 1982 private:
kenjiArai 0:5b88d5760320 1983 InstanceID_t instanceID;
kenjiArai 0:5b88d5760320 1984 BLEInstanceBase *transport; /* The device-specific backend */
kenjiArai 0:5b88d5760320 1985 OnEventsToProcessCallback_t whenEventsToProcess;
kenjiArai 0:5b88d5760320 1986 bool event_signaled;
kenjiArai 0:5b88d5760320 1987 };
kenjiArai 0:5b88d5760320 1988
kenjiArai 0:5b88d5760320 1989 /**
kenjiArai 0:5b88d5760320 1990 * @deprecated This type alias is retained for the sake of compatibility with
kenjiArai 0:5b88d5760320 1991 * older code. This will be dropped at some point.
kenjiArai 0:5b88d5760320 1992 */
kenjiArai 0:5b88d5760320 1993 typedef BLE BLEDevice;
kenjiArai 0:5b88d5760320 1994
kenjiArai 0:5b88d5760320 1995 /**
kenjiArai 0:5b88d5760320 1996 * @namespace ble Entry namespace for all %BLE API definitions.
kenjiArai 0:5b88d5760320 1997 */
kenjiArai 0:5b88d5760320 1998
kenjiArai 0:5b88d5760320 1999 /**
kenjiArai 0:5b88d5760320 2000 * @}
kenjiArai 0:5b88d5760320 2001 */
kenjiArai 0:5b88d5760320 2002
kenjiArai 0:5b88d5760320 2003 #endif /* ifndef MBED_BLE_H__ */