Revision 1115:82d4a8a56d91, committed 2016-01-11

Comitter:

vcoubard

Date:

Mon Jan 11 08:52:01 2016 +0000

Parent:

1114:04913cb9706e

Child:

1116:9cb51490b3f7

Commit message:

Synchronized with git rev f7570e8b
Author: Andres Amaya Garcia
Early whitelisting API

Changed in this revision

--- a/ble/BLE.h	Mon Jan 11 08:52:00 2016 +0000
+++ b/ble/BLE.h	Mon Jan 11 08:52:01 2016 +0000
@@ -239,7 +239,7 @@
      * ble.setAddress(...) should be replaced with
      * ble.gap().setAddress(...).
      */
-    ble_error_t setAddress(BLEProtocol::AddressType_t type, const BLEProtocol::Address_t address) {
+    ble_error_t setAddress(BLEProtocol::AddressType_t type, const BLEProtocol::AddressBytes_t address) {
         return gap().setAddress(type, address);
     }
 
@@ -252,7 +252,7 @@
      * ble.getAddress(...) should be replaced with
      * ble.gap().getAddress(...).
      */
-    ble_error_t getAddress(BLEProtocol::AddressType_t *typeP, BLEProtocol::Address_t address) {
+    ble_error_t getAddress(BLEProtocol::AddressType_t *typeP, BLEProtocol::AddressBytes_t address) {
         return gap().getAddress(typeP, address);
     }
 
@@ -752,7 +752,7 @@
      * ble.connect(...) should be replaced with
      * ble.gap().connect(...).
      */
-    ble_error_t connect(const BLEProtocol::Address_t   peerAddr,
+    ble_error_t connect(const BLEProtocol::AddressBytes_t   peerAddr,
                         BLEProtocol::AddressType_t     peerAddrType = BLEProtocol::AddressType::RANDOM_STATIC,
                         const Gap::ConnectionParams_t *connectionParams = NULL,
                         const GapScanningParams       *scanParams = NULL) {

--- a/ble/BLEProtocol.h	Mon Jan 11 08:52:00 2016 +0000
+++ b/ble/BLEProtocol.h	Mon Jan 11 08:52:01 2016 +0000
@@ -19,6 +19,8 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <algorithm>
+#include <string.h>
 
 /**
  * A common namespace for types and constants used everywhere in BLE API.
@@ -43,7 +45,31 @@
     typedef AddressType::Type AddressType_t; /**< Alias for AddressType::Type */
 
     static const size_t ADDR_LEN = 6;        /**< Length (in octets) of the BLE MAC address. */
-    typedef uint8_t Address_t[ADDR_LEN];     /**< 48-bit address, in LSB format. */
+    typedef uint8_t AddressBytes_t[ADDR_LEN];     /**< 48-bit address, in LSB format. */
+
+    /**
+     * BLE address. It contains an address-type (@ref AddressType_t) and bytes (@ref AddressBytes_t).
+     */
+    struct Address_t {
+        AddressType_t  type;    /**< @ref AddressType_t */
+        AddressBytes_t address; /**< @ref AddressBytes_t */
+
+        Address_t(AddressType_t typeIn, const AddressBytes_t& addressIn) : type(typeIn) {
+            std::copy(addressIn, addressIn + ADDR_LEN, address);
+        }
+
+        Address_t(void) : type(AddressType::PUBLIC), address() {
+        }
+
+        bool operator<(const Address_t &rhs) const {
+            if (type < rhs.type) {
+                return true;
+            } else if (type > rhs.type) {
+                return false;
+            }
+            return (memcmp(address, rhs.address, sizeof(AddressBytes_t)) < 0) ? true : false;
+        }
+    };
 };
 
 #endif /* __BLE_PROTOCOL_H__ */
\ No newline at end of file

--- a/ble/CharacteristicDescriptorDiscovery.h	Mon Jan 11 08:52:00 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,99 +0,0 @@
-/* mbed Microcontroller Library
- * Copyright (c) 2006-2015 ARM Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CHARACTERISTIC_DESCRIPTOR_DISCOVERY_H__
-#define __CHARACTERISTIC_DESCRIPTOR_DISCOVERY_H__
-
-#include "FunctionPointerWithContext.h"
-
-class DiscoveredCharacteristic;                         // forward declaration
-class DiscoveredCharacteristicDescriptor;               // forward declaration
-
-/**
- * @brief Contain all definitions of callbacks and callbacks parameters types
- * related to characteristic descriptor discovery.
- *
- * @details This class act like a namespace for characteristic descriptor discovery
- * types. It act like ServiceDiscovery by providing callbacks and callbacks
- * parameters types related to the characteristic descriptor discovery process but
- * contrary to ServiceDiscovery class, it does not force the porter to use a
- * specific interface for the characteristic descriptor discovery process.
- */
-class CharacteristicDescriptorDiscovery {
-public:
-    /**
-     * @brief Parameter type of CharacteristicDescriptorDiscovery::DiscoveryCallback_t.
-     * @detail Every time a characteristic descriptor has been discovered, the callback
-     * registered for the discovery operation through GattClient::discoverCharacteristicDescriptors
-     * or DiscoveredCharacteristic::discoverDescriptors will be called with this parameter.
-     *
-     */
-    struct DiscoveryCallbackParams_t {
-        /**
-         * The characteristic owning the DiscoveredCharacteristicDescriptor
-         */
-        const DiscoveredCharacteristic& characteristic;
-
-        /**
-         * The characteristic descriptor discovered
-         */
-        const DiscoveredCharacteristicDescriptor& descriptor;
-    };
-
-    /**
-     * @brief Parameter type of CharacteristicDescriptorDiscovery::TerminationCallback_t.
-     * @details Once a characteristic descriptor discovery process terminate, the termination
-     * callback registered for the discovery operation through
-     * GattClient::discoverCharacteristicDescriptors or DiscoveredCharacteristic::discoverDescriptors
-     * will be called with this parameter.
-     */
-    struct TerminationCallbackParams_t {
-        /**
-         * The characteristic for which the descriptors has been discovered
-         */
-        const DiscoveredCharacteristic& characteristic;
-
-        /**
-         * status of the discovery operation
-         */
-        ble_error_t status;
-    };
-
-    /**
-     * @brief Callback type for when a matching characteristic descriptor is found during
-     * characteristic descriptor discovery.
-     *
-     * @param param A pointer to a DiscoveryCallbackParams_t object which will remain
-     * valid for the lifetime of the callback. Memory for this object is owned by
-     * the BLE_API eventing framework. The application can safely make a persistent
-     * shallow-copy of this object in order to work with the service beyond the
-     * callback.
-     */
-    typedef FunctionPointerWithContext<const DiscoveryCallbackParams_t*> DiscoveryCallback_t;
-
-    /**
-     * @brief Callback type for when characteristic descriptor discovery terminates.
-     *
-     * @param param A pointer to a TerminationCallbackParams_t object which will remain
-     * valid for the lifetime of the callback. Memory for this object is owned by
-     * the BLE_API eventing framework. The application can safely make a persistent
-     * shallow-copy of this object in order to work with the service beyond the
-     * callback.
-     */
-    typedef FunctionPointerWithContext<const TerminationCallbackParams_t*> TerminationCallback_t;
-};
-
-#endif // ifndef __CHARACTERISTIC_DESCRIPTOR_DISCOVERY_H__
\ No newline at end of file

--- a/ble/DiscoveredCharacteristic.h	Mon Jan 11 08:52:00 2016 +0000
+++ b/ble/DiscoveredCharacteristic.h	Mon Jan 11 08:52:01 2016 +0000
@@ -21,24 +21,10 @@
 #include "Gap.h"
 #include "GattAttribute.h"
 #include "GattClient.h"
-#include "CharacteristicDescriptorDiscovery.h"
-#include "ble/DiscoveredCharacteristicDescriptor.h"
 
 /**
- * @brief Representation of a characteristic discovered during a GattClient
- * discovery procedure (see GattClient::launchServiceDiscovery ).
- *
- * @detail Provide detailed informations about a discovered characteristic like:
- *     - Its UUID (see #getUUID).
- *     - The most important handles of the characteristic definition
- *       (see #getDeclHandle, #getValueHandle, #getLastHandle )
- *     - Its properties (see #getProperties).
- * This class also provide functions to operate on the characteristic:
- *     - Read the characteristic value (see #read)
- *     - Writing a characteristic value (see #write or #writeWoResponse)
- *     - Discover descriptors inside the characteristic definition. These descriptors
- *       extends the characteristic. More information about descriptor usage is
- *       available in DiscoveredCharacteristicDescriptor class.
+ * Structure for holding information about the service and the characteristics
+ * found during the discovery process.
  */
 class DiscoveredCharacteristic {
 public:
@@ -47,7 +33,7 @@
         uint8_t _read            :1; /**< Reading the value permitted. */
         uint8_t _writeWoResp     :1; /**< Writing the value with Write Command permitted. */
         uint8_t _write           :1; /**< Writing the value with Write Request permitted. */
-        uint8_t _notify          :1; /**< Notifications of the value permitted. */
+        uint8_t _notify          :1; /**< Notications of the value permitted. */
         uint8_t _indicate        :1; /**< Indications of the value permitted. */
         uint8_t _authSignedWrite :1; /**< Writing the value with Signed Write Command permitted. */
 
@@ -60,50 +46,36 @@
         bool indicate(void)        const {return _indicate;       }
         bool authSignedWrite(void) const {return _authSignedWrite;}
 
-        /**
-         * @brief "Equal to" operator for DiscoveredCharacteristic::Properties_t
-         *
-         * @param lhs[in] The left hand side of the equality expression
-         * @param rhs[in] The right hand side of the equality expression
-         *
-         * @return true if operands are equals, false otherwise.
-         */
-        friend bool operator==(Properties_t lhs, Properties_t rhs) {
-            return lhs._broadcast == rhs._broadcast &&
-                   lhs._read == rhs._read &&
-                   lhs._writeWoResp == rhs._writeWoResp &&
-                   lhs._write == rhs._write &&
-                   lhs._notify == rhs._notify &&
-                   lhs._indicate == rhs._indicate &&
-                   lhs._authSignedWrite == rhs._authSignedWrite;
-        }
-
-        /**
-         * @brief "Not equal to" operator for DiscoveredCharacteristic::Properties_t
-         *
-         * @param lhs The right hand side of the expression
-         * @param rhs The left hand side of the expression
-         *
-         * @return true if operands are not equals, false otherwise.
-         */
-        friend bool operator!=(Properties_t lhs, Properties_t rhs) {
-            return !(lhs == rhs);
-        }
-
     private:
         operator uint8_t()  const; /* Disallow implicit conversion into an integer. */
         operator unsigned() const; /* Disallow implicit conversion into an integer. */
     };
 
     /**
+     * Structure for holding information about the service and the characteristics
+     * found during the discovery process.
+     */
+    struct DiscoveredDescriptor {
+        GattAttribute::Handle_t handle; /**< Descriptor Handle. */
+        UUID                    uuid;   /**< Descriptor UUID. */
+    };
+
+    /**
+     * Callback type for when a characteristic descriptor is found during descriptor-
+     * discovery. The receiving function is passed in a pointer to a
+     * DiscoveredDescriptor object which will remain valid for the lifetime
+     * of the callback. Memory for this object is owned by the BLE_API eventing
+     * framework. The application can safely make a persistent shallow-copy of
+     * this object in order to work with the characteristic beyond the callback.
+     */
+    typedef void (*DescriptorCallback_t)(const DiscoveredDescriptor *);
+
+    /**
      * Initiate (or continue) a read for the value attribute, optionally at a
      * given offset. If the characteristic or descriptor to be read is longer
      * than ATT_MTU - 1, this function must be called multiple times with
      * appropriate offset to read the complete value.
      *
-     * @param offset[in] The position - in the characteristic value bytes stream - where
-     * the read operation begin.
-     *
      * @return BLE_ERROR_NONE if a read has been initiated, or
      *         BLE_ERROR_INVALID_STATE if some internal state about the connection is invalid, or
      *         BLE_STACK_BUSY if some client procedure is already in progress, or
@@ -111,22 +83,14 @@
      */
     ble_error_t read(uint16_t offset = 0) const;
 
-    /**
-     * @brief Same as #read(uint16_t) const but allow the user to register a callback
-     * which will be fired once the read is done.
-     *
-     * @param offset[in] The position - in the characteristic value bytes stream - where
-     * the read operation begin.
-     * @param onRead[in] Continuation of the read operation
-     */
     ble_error_t read(uint16_t offset, const GattClient::ReadCallback_t& onRead) const;
 
     /**
      * Perform a write without response procedure.
      *
-     * @param[in]  length
+     * @param  length
      *           The amount of data being written.
-     * @param[in]  value
+     * @param  value
      *           The bytes being written.
      *
      * @note   It is important to note that a write without response will generate
@@ -146,20 +110,20 @@
     /**
      * Initiate a GATT Characteristic Descriptor Discovery procedure for descriptors within this characteristic.
      *
-     * @param[in] onDescriptorDiscovered This callback will be called every time a descriptor is discovered
-     * @param[in] onTermination This callback will be called when the discovery process is over.
+     * @param  callback
+     * @param  matchingUUID
+     *           Filter for descriptors. Defaults to wildcard which will discover all descriptors.
      *
-     * @return BLE_ERROR_NONE if descriptor discovery is launched successfully; else an appropriate error.
+     * @return  BLE_ERROR_NONE if descriptor discovery is launched successfully; else an appropriate error.
      */
-    ble_error_t discoverDescriptors(const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& onDescriptorDiscovered,
-                                    const CharacteristicDescriptorDiscovery::TerminationCallback_t& onTermination) const;
+    ble_error_t discoverDescriptors(DescriptorCallback_t callback, const UUID &matchingUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN)) const;
 
     /**
      * Perform a write procedure.
      *
-     * @param[in]  length
+     * @param  length
      *           The amount of data being written.
-     * @param[in]  value
+     * @param  value
      *           The bytes being written.
      *
      * @note   It is important to note that a write will generate
@@ -174,142 +138,36 @@
     ble_error_t write(uint16_t length, const uint8_t *value) const;
 
     /**
-     * Same as #write(uint16_t, const uint8_t *) const but register a callback
-     * which will be called once the data has been written.
-     *
-     * @param[in] length The amount of bytes to write.
-     * @param[in] value The bytes to write.
-     * @param[in] onRead Continuation callback for the write operation
+     * Same as above but register the callback wich will be called once the data has been written
      */
-    ble_error_t write(uint16_t length, const uint8_t *value, const GattClient::WriteCallback_t& onWrite) const;
+    ble_error_t write(uint16_t length, const uint8_t *value, const GattClient::WriteCallback_t& onRead) const;
 
     void setupLongUUID(UUID::LongUUIDBytes_t longUUID, UUID::ByteOrder_t order = UUID::MSB) {
         uuid.setupLong(longUUID, order);
     }
 
 public:
-    /**
-     * @brief Get the UUID of the discovered characteristic
-     * @return the UUID of this characteristic
-     */
     const UUID& getUUID(void) const {
         return uuid;
     }
 
-    /**
-     * @brief Get the properties of this characteristic
-     * @return the set of properties of this characteristic
-     */
     const Properties_t& getProperties(void) const {
         return props;
     }
 
-    /**
-     * @brief Get the declaration handle of this characteristic.
-     * @detail The declaration handle is the first handle of a characteristic
-     * definition. The value accessible at this handle contains the following
-     * informations:
-     *    - The characteristics properties (see Properties_t). This value can
-     *      be accessed by using #getProperties .
-     *    - The characteristic value attribute handle. This field can be accessed
-     *      by using #getValueHandle .
-     *    - The characteristic UUID, this value can be accessed by using the
-     *      function #getUUID .
-     * @return the declaration handle of this characteristic.
-     */
-    GattAttribute::Handle_t getDeclHandle(void) const {
+    const GattAttribute::Handle_t& getDeclHandle(void) const {
         return declHandle;
     }
-
-    /**
-     * @brief Return the handle used to access the value of this characteristic.
-     * @details This handle is the one provided in the characteristic declaration
-     * value. Usually, it is equal to #getDeclHandle() + 1. But it is not always
-     * the case. Anyway, users are allowed to use #getDeclHandle() + 1 to access
-     * the value of a characteristic.
-     * @return The handle to access the value of this characteristic.
-     */
-    GattAttribute::Handle_t getValueHandle(void) const {
+    const GattAttribute::Handle_t& getValueHandle(void) const {
         return valueHandle;
     }
 
-    /**
-     * @brief Return the last handle of the characteristic definition.
-     * @details A Characteristic definition can contain a lot of handles:
-     *     - one for the declaration (see #getDeclHandle)
-     *     - one for the value (see #getValueHandle)
-     *     - zero of more for the characteristic descriptors.
-     * This handle is the last handle of the characteristic definition.
-     * @return The last handle of this characteristic definition.
-     */
-    GattAttribute::Handle_t getLastHandle(void) const {
-        return lastHandle;
-    }
-
-    /**
-     * @brief Return the GattClient which can operate on this characteristic.
-     * @return The GattClient which can operate on this characteristic.
-     */
-    GattClient* getGattClient() {
-        return gattc;
-    }
-
-    /**
-     * @brief Return the GattClient which can operate on this characteristic.
-     * @return The GattClient which can operate on this characteristic.
-     */
-    const GattClient* getGattClient() const {
-        return gattc;
-    }
-
-    /**
-     * @brief Return the connection handle to the GattServer which contain
-     * this characteristic.
-     * @return the connection handle to the GattServer which contain
-     * this characteristic.
-     */
-    Gap::Handle_t getConnectionHandle() const {
-        return connHandle;
-    }
-
-    /**
-     * @brief "Equal to" operator for DiscoveredCharacteristic
-     *
-     * @param lhs[in] The left hand side of the equality expression
-     * @param rhs[in] The right hand side of the equality expression
-     *
-     * @return true if operands are equals, false otherwise.
-     */
-    friend bool operator==(const DiscoveredCharacteristic& lhs, const DiscoveredCharacteristic& rhs) {
-        return lhs.gattc == rhs.gattc &&
-               lhs.uuid == rhs.uuid &&
-               lhs.props == rhs.props &&
-               lhs.declHandle == rhs.declHandle &&
-               lhs.valueHandle == rhs.valueHandle &&
-               lhs.lastHandle == rhs.lastHandle &&
-               lhs.connHandle == rhs.connHandle;
-    }
-
-    /**
-     * @brief "Not equal to" operator for DiscoveredCharacteristic
-     *
-     * @param lhs[in] The right hand side of the expression
-     * @param rhs[in] The left hand side of the expression
-     *
-     * @return true if operands are not equals, false otherwise.
-     */
-    friend bool operator !=(const DiscoveredCharacteristic& lhs, const DiscoveredCharacteristic& rhs) {
-        return !(lhs == rhs);
-    }
-
 public:
     DiscoveredCharacteristic() : gattc(NULL),
                                  uuid(UUID::ShortUUIDBytes_t(0)),
                                  props(),
                                  declHandle(GattAttribute::INVALID_HANDLE),
-                                 valueHandle(GattAttribute::INVALID_HANDLE),
-                                 lastHandle(GattAttribute::INVALID_HANDLE),
-                                 connHandle() {
+                                 valueHandle(GattAttribute::INVALID_HANDLE) {
         /* empty */
     }
 
@@ -321,7 +179,6 @@
     Properties_t             props;
     GattAttribute::Handle_t  declHandle;
     GattAttribute::Handle_t  valueHandle;
-    GattAttribute::Handle_t  lastHandle;
 
     Gap::Handle_t            connHandle;
 };

--- a/ble/DiscoveredCharacteristicDescriptor.h	Mon Jan 11 08:52:00 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,111 +0,0 @@
-/* mbed Microcontroller Library
- * Copyright (c) 2006-2013 ARM Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DISCOVERED_CHARACTERISTIC_DESCRIPTOR_H__
-#define __DISCOVERED_CHARACTERISTIC_DESCRIPTOR_H__
-
-#include "UUID.h"
-#include "Gap.h"
-#include "GattAttribute.h"
-#include "GattClient.h"
-#include "CharacteristicDescriptorDiscovery.h"
-
-/**
- * @brief Representation of a descriptor discovered during a GattClient
- * discovery procedure (see GattClient::discoverCharacteristicDescriptors or
- * DiscoveredCharacteristic::discoverDescriptors ).
- *
- * @detail Provide detailed informations about a discovered characteristic descriptor
- * like:
- *     - Its UUID (see #getUUID).
- *     - Its handle (see #getAttributeHandle)
- * Basic read (see GattClient::read) and write (see GattClient::write) procedure from
- * GattClient can be used access the value of the descriptor.
- *
- * @todo read member function
- * @todo write member function
- * @todo enumeration of standard descriptors
- */
-class DiscoveredCharacteristicDescriptor {
-
-public:
-
-    /**
-     * @brief construct a new instance of a DiscoveredCharacteristicDescriptor
-     *
-     * @param client The client from where the descriptor has been discovered
-     * @param connectionHandle The connection handle on which the descriptor has
-     * been discovered
-     * @param attributeHandle The handle of the attribute containing this descriptor
-     * @param uuid The UUID of the descriptor
-     */
-    DiscoveredCharacteristicDescriptor(
-        GattClient* client, Gap::Handle_t connectionHandle,  GattAttribute::Handle_t attributeHandle, const UUID& uuid) :
-        _client(client), _connectionHandle(connectionHandle), _uuid(uuid), _gattHandle(attributeHandle) {
-
-    }
-
-    /**
-     * @brief Return the GattClient which can operate on this descriptor.
-     * @return The GattClient which can operate on this descriptor.
-     */
-    GattClient* getGattClient() {
-        return _client;
-    }
-
-    /**
-     * @brief Return the GattClient which can operate on this descriptor.
-     * @return The GattClient which can operate on this descriptor.
-     */
-    const GattClient* getGattClient() const {
-        return _client;
-    }
-
-    /**
-     * @brief Return the connection handle to the GattServer which contain
-     * this descriptor.
-     * @return the connection handle to the GattServer which contain
-     * this descriptor.
-     */
-    Gap::Handle_t getConnectionHandle() const {
-        return _connectionHandle;
-    }
-
-    /**
-     * @brief Return the UUID of this descriptor
-     * @return the UUID of this descriptor
-     */
-    const UUID& getUUID(void) const {
-        return _uuid;
-    }
-
-    /**
-     * @brief Return the attribute handle to use to access to this descriptor
-     * on the gatt server.
-     * @return The attribute handle of the descriptor
-     */
-    GattAttribute::Handle_t getAttributeHandle() const {
-        return _gattHandle;
-    }
-
-private:
-    GattClient  *_client;
-    Gap::Handle_t _connectionHandle;
-    UUID _uuid;
-    GattAttribute::Handle_t _gattHandle;
-};
-
-#endif /*__DISCOVERED_CHARACTERISTIC_DESCRIPTOR_H__*/
\ No newline at end of file

--- a/ble/Gap.h	Mon Jan 11 08:52:00 2016 +0000
+++ b/ble/Gap.h	Mon Jan 11 08:52:01 2016 +0000
@@ -24,7 +24,7 @@
 #include "GapEvents.h"
 #include "CallChainOfFunctionPointersWithContext.h"
 #include "FunctionPointerWithContext.h"
-#include "deprecate.h"
+#include <set>
 
 /* Forward declarations for classes that will only be used for pointers or references in the following. */
 class GapAdvertisingParams;
@@ -52,13 +52,13 @@
 
     /**
      * Address-type for BLEProtocol addresses.
-     * \deprecated: Use BLEProtocol::AddressType_t instead.
+     * @note: deprecated. Use BLEProtocol::AddressType_t instead.
      *
      * DEPRECATION ALERT: The following constants have been left in their
      * deprecated state to transparenly support existing applications which may
      * have used Gap::ADDR_TYPE_*.
      */
-    enum DeprecatedAddressType_t {
+    enum {
         ADDR_TYPE_PUBLIC                        = BLEProtocol::AddressType::PUBLIC,
         ADDR_TYPE_RANDOM_STATIC                 = BLEProtocol::AddressType::RANDOM_STATIC,
         ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE     = BLEProtocol::AddressType::RANDOM_PRIVATE_RESOLVABLE,
@@ -66,8 +66,8 @@
     };
 
     static const unsigned ADDR_LEN = BLEProtocol::ADDR_LEN; /**< Length (in octets) of the BLE MAC address. */
-    typedef BLEProtocol::Address_t Address_t; /**< 48-bit address, LSB format. @Note: Deprecated. Use BLEProtocol::Address_t instead. */
-    typedef BLEProtocol::Address_t address_t; /**< 48-bit address, LSB format. @Note: Deprecated. Use BLEProtocol::Address_t instead. */
+    typedef BLEProtocol::AddressBytes_t Address_t; /**< 48-bit address, LSB format. @Note: Deprecated. Use BLEProtocol::Address_t instead. */
+    typedef BLEProtocol::AddressBytes_t address_t; /**< 48-bit address, LSB format. @Note: Deprecated. Use BLEProtocol::Address_t instead. */
 
 public:
     enum TimeoutSource_t {
@@ -114,7 +114,7 @@
     };
 
     struct AdvertisementCallbackParams_t {
-        BLEProtocol::Address_t                   peerAddr;
+        BLEProtocol::AddressBytes_t                   peerAddr;
         int8_t                                   rssi;
         bool                                     isScanResponse;
         GapAdvertisingParams::AdvertisingType_t  type;
@@ -127,9 +127,9 @@
         Handle_t                    handle;
         Role_t                      role;
         BLEProtocol::AddressType_t  peerAddrType;
-        BLEProtocol::Address_t      peerAddr;
+        BLEProtocol::AddressBytes_t      peerAddr;
         BLEProtocol::AddressType_t  ownAddrType;
-        BLEProtocol::Address_t      ownAddr;
+        BLEProtocol::AddressBytes_t      ownAddr;
         const ConnectionParams_t   *connectionParams;
 
         ConnectionCallbackParams_t(Handle_t                    handleIn,
@@ -191,7 +191,7 @@
      *
      * @return BLE_ERROR_NONE on success.
      */
-    virtual ble_error_t setAddress(BLEProtocol::AddressType_t type, const BLEProtocol::Address_t address) {
+    virtual ble_error_t setAddress(BLEProtocol::AddressType_t type, const BLEProtocol::AddressBytes_t address) {
         /* avoid compiler warnings about unused variables */
         (void)type;
         (void)address;
@@ -204,7 +204,7 @@
      *
      * @return BLE_ERROR_NONE on success.
      */
-    virtual ble_error_t getAddress(BLEProtocol::AddressType_t *typeP, BLEProtocol::Address_t address) {
+    virtual ble_error_t getAddress(BLEProtocol::AddressType_t *typeP, BLEProtocol::AddressBytes_t address) {
         /* Avoid compiler warnings about unused variables. */
         (void)typeP;
         (void)address;
@@ -263,7 +263,7 @@
      *     successfully. The connectionCallChain (if set) will be invoked upon
      *     a connection event.
      */
-    virtual ble_error_t connect(const BLEProtocol::Address_t  peerAddr,
+    virtual ble_error_t connect(const BLEProtocol::AddressBytes_t  peerAddr,
                                 BLEProtocol::AddressType_t    peerAddrType,
                                 const ConnectionParams_t     *connectionParams,
                                 const GapScanningParams      *scanParams) {
@@ -277,23 +277,6 @@
     }
 
     /**
-     * Create a connection (GAP Link Establishment).
-     *
-     * \deprecated: This funtion overloads Gap::connect(const BLEProtocol::Address_t  peerAddr,
-                                                        BLEProtocol::AddressType_t    peerAddrType,
-                                                        const ConnectionParams_t     *connectionParams,
-                                                        const GapScanningParams      *scanParams)
-     *      to maintain backward compatibility for change from Gap::AddressType_t to BLEProtocol::AddressType_t
-     */
-    ble_error_t connect(const BLEProtocol::Address_t  peerAddr,
-                        DeprecatedAddressType_t       peerAddrType,
-                        const ConnectionParams_t     *connectionParams,
-                        const GapScanningParams      *scanParams)
-    __deprecated_message("Gap::DeprecatedAddressType_t is deprecated, use BLEProtocol::AddressType_t instead") {
-        return connect(peerAddr, (BLEProtocol::AddressType_t) peerAddrType, connectionParams, scanParams);
-    }
-
-    /**
      * This call initiates the disconnection procedure, and its completion will
      * be communicated to the application with an invocation of the
      * disconnectionCallback.
@@ -1135,9 +1118,9 @@
     void processConnectionEvent(Handle_t                      handle,
                                 Role_t                        role,
                                 BLEProtocol::AddressType_t    peerAddrType,
-                                const BLEProtocol::Address_t  peerAddr,
+                                const BLEProtocol::AddressBytes_t  peerAddr,
                                 BLEProtocol::AddressType_t    ownAddrType,
-                                const BLEProtocol::Address_t  ownAddr,
+                                const BLEProtocol::AddressBytes_t  ownAddr,
                                 const ConnectionParams_t     *connectionParams) {
         state.connected = 1;
         ConnectionCallbackParams_t callbackParams(handle, role, peerAddrType, peerAddr, ownAddrType, ownAddr, connectionParams);
@@ -1150,7 +1133,7 @@
         disconnectionCallChain.call(&callbackParams);
     }
 
-    void processAdvertisementReport(const BLEProtocol::Address_t             peerAddr,
+    void processAdvertisementReport(const BLEProtocol::AddressBytes_t             peerAddr,
                                     int8_t                                   rssi,
                                     bool                                     isScanResponse,
                                     GapAdvertisingParams::AdvertisingType_t  type,
@@ -1172,6 +1155,76 @@
         }
     }
 
+///////////////////////////////////////////////////
+public:
+    enum AdvertisingPolicyMode_t {
+        ADV_POLICY_IGNORE_WHITELIST = 0,
+        ADV_POLICY_FILTER_SCAN_REQS = 1,
+        ADV_POLICY_FILTER_CONN_REQS = 2,
+        ADV_POLICY_FILTER_ALL_REQS  = 3,
+    };
+
+    enum ScanningPolicyMode_t {
+        SCAN_POLICY_IGNORE_WHITELIST = 0,
+        SCAN_POLICY_FILTER_ALL_ADV   = 1,
+    };
+
+    enum InitiatorPolicyMode_t {
+        INIT_POLICY_IGNORE_WHITELIST = 0,
+        INIT_POLICY_FILTER_ALL_ADV   = 1,
+    };
+
+    // Things to be implemented by the porter
+    virtual int8_t getMaxWhitelistSize(void) const
+    {
+        return BLE_ERROR_NOT_IMPLEMENTED;
+    }
+
+    virtual ble_error_t getWhitelist(std::set<BLEProtocol::Address_t> &whitelist) const
+    {
+        (void) whitelist;
+        return BLE_ERROR_NOT_IMPLEMENTED;
+    }
+
+    virtual ble_error_t setWhitelist(std::set<BLEProtocol::Address_t> whitelist)
+    {
+        (void) whitelist;
+        return BLE_ERROR_NOT_IMPLEMENTED;
+    }
+
+    // Accessors
+    virtual void setAdvertisingPolicyMode(AdvertisingPolicyMode_t mode)
+    {
+        (void) mode;
+    }
+
+    virtual void setScanningPolicyMode(ScanningPolicyMode_t mode)
+    {
+        (void) mode;
+    }
+
+    virtual void setInitiatorPolicyMode(InitiatorPolicyMode_t mode)
+    {
+        (void) mode;
+    }
+
+    virtual AdvertisingPolicyMode_t getAdvertisingPolicyMode(void) const
+    {
+        return ADV_POLICY_IGNORE_WHITELIST;
+    }
+
+    virtual ScanningPolicyMode_t getScanningPolicyMode(void) const
+    {
+        return SCAN_POLICY_IGNORE_WHITELIST;
+    }
+
+    virtual InitiatorPolicyMode_t getInitiatorPolicyMode(void) const
+    {
+        return INIT_POLICY_IGNORE_WHITELIST;
+    }
+
+///////////////////////////////////////////////////
+
 protected:
     GapAdvertisingParams             _advParams;
     GapAdvertisingData               _advPayload;

--- a/ble/GattClient.h	Mon Jan 11 08:52:00 2016 +0000
+++ b/ble/GattClient.h	Mon Jan 11 08:52:01 2016 +0000
@@ -20,7 +20,6 @@
 #include "Gap.h"
 #include "GattAttribute.h"
 #include "ServiceDiscovery.h"
-#include "CharacteristicDescriptorDiscovery.h"
 
 #include "GattCallbackParamTypes.h"
 
@@ -220,8 +219,8 @@
      * Initiate a GATT Client write procedure.
      *
      * @param[in] cmd
-     *              Command can be either a write-request (which generates a
-     *              matching response from the peripheral), or a write-command
+     *              Command can be either a write-request (which generates a 
+     *              matching response from the peripheral), or a write-command 
      *              (which doesn't require the connected peer to respond).
      * @param[in] connHandle
      *              Connection handle.
@@ -250,8 +249,8 @@
     /* Event callback handlers. */
 public:
     /**
-     * Set up a callback for read response events.
-     * It is possible to remove registered callbacks using
+     * Set up a callback for read response events. 
+     * It is possible to remove registered callbacks using 
      * onDataRead().detach(callbackToRemove)
      */
     void onDataRead(ReadCallback_t callback) {
@@ -261,7 +260,7 @@
     /**
      * @brief provide access to the callchain of read callbacks
      * It is possible to register callbacks using onDataRead().add(callback);
-     * It is possible to unregister callbacks using onDataRead().detach(callback)
+     * It is possible to unregister callbacks using onDataRead().detach(callback) 
      * @return The read callbacks chain
      */
     ReadCallbackChain_t& onDataRead() {
@@ -270,7 +269,7 @@
 
     /**
      * Set up a callback for write response events.
-     * It is possible to remove registered callbacks using
+     * It is possible to remove registered callbacks using 
      * onDataWritten().detach(callbackToRemove).
      * @Note: Write commands (issued using writeWoResponse) don't generate a response.
      */
@@ -281,10 +280,10 @@
     /**
      * @brief provide access to the callchain of data written callbacks
      * It is possible to register callbacks using onDataWritten().add(callback);
-     * It is possible to unregister callbacks using onDataWritten().detach(callback)
+     * It is possible to unregister callbacks using onDataWritten().detach(callback) 
      * @return The data written callbacks chain
      */
-    WriteCallbackChain_t& onDataWritten() {
+    WriteCallbackChain_t& onDataWritten() { 
         return onDataWriteCallbackChain;
     }
 
@@ -309,59 +308,6 @@
     }
 
     /**
-     * @brief launch discovery of descriptors for a given characteristic
-     * @details This function will discover all descriptors available for a
-     * specific characteristic.
-     *
-     * @param characteristic[in] The characteristic targeted by this discovery
-     * procedure
-     * @param discoveryCallback[in] User function called each time a descriptor
-     * is found during the procedure.
-     * @param terminationCallback[in] User provided function which will be called
-     * once the discovery procedure is terminating. This will get called when all
-     * the descriptors have been discovered or if an error occur during the discovery
-     * procedure.
-     *
-     * @return
-     *   BLE_ERROR_NONE if characteristic descriptor discovery is launched
-     *   successfully; else an appropriate error.
-     */
-    virtual ble_error_t discoverCharacteristicDescriptors(
-        const DiscoveredCharacteristic& characteristic,
-        const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback,
-        const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback) {
-        (void) characteristic;
-        (void) discoveryCallback;
-        (void) terminationCallback;
-        /* Requesting action from porter(s): override this API if this capability is supported. */
-        return BLE_ERROR_NOT_IMPLEMENTED;
-    }
-
-    /**
-     * @brief Indicate if the discovery of characteristic descriptors is active for a given characteristic
-     * or not.
-     * @param characteristic[in] The characteristic concerned by the descriptors discovery.
-     * @return true if a descriptors discovery is active for the characteristic in input; otherwise false.
-     */
-    virtual bool isCharacteristicDescriptorDiscoveryActive(const DiscoveredCharacteristic& characteristic) const
-     {
-        (void) characteristic;
-        return false; /* Requesting action from porter(s): override this API if this capability is supported. */
-    }
-
-    /**
-     * @brief Terminate an ongoing characteristic descriptor discovery.
-     * @detail This should result in an invocation of the TerminationCallback if
-     * the characteristic descriptor discovery is active.
-     * @param characteristic[in] The characteristic on which the running descriptors
-     * discovery should be stopped.
-     */
-    virtual void terminateCharacteristicDescriptorDiscovery(const DiscoveredCharacteristic& characteristic) {
-        /* Requesting action from porter(s): override this API if this capability is supported. */
-        (void) characteristic;
-    }
-
-    /**
      * Set up a callback for when the GATT client receives an update event
      * corresponding to a change in the value of a characteristic on the remote
      * GATT server.
@@ -406,10 +352,10 @@
     /**
      * @brief provide access to the callchain of HVX callbacks
      * It is possible to register callbacks using onHVX().add(callback);
-     * It is possible to unregister callbacks using onHVX().detach(callback)
+     * It is possible to unregister callbacks using onHVX().detach(callback) 
      * @return The HVX callbacks chain
      */
-    HVXCallbackChain_t& onHVX() {
+    HVXCallbackChain_t& onHVX() { 
         return onHVXCallbackChain;
     }
 

--- a/ble/deprecate.h	Mon Jan 11 08:52:00 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,26 +0,0 @@
-/* mbed Microcontroller Library
- * Copyright (c) 2006-2013 ARM Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DEPRECATE_H__
-#define __DEPRECATE_H__
-
-#ifdef YOTTA_CFG_MBED_OS
-	#include "compiler-polyfill/attributes.h"
-#else
-	#define __deprecated_message(msg)
-#endif
-
-#endif
\ No newline at end of file

--- a/module.json	Mon Jan 11 08:52:00 2016 +0000
+++ b/module.json	Mon Jan 11 08:52:01 2016 +0000
@@ -1,6 +1,6 @@
 {
   "name": "ble",
-  "version": "2.3.0",
+  "version": "2.2.2",
   "description": "The BLE module offers a high level abstraction for using Bluetooth Low Energy on multiple platforms.",
   "keywords": [
     "Bluetooth",
@@ -35,8 +35,7 @@
       "mbed-classic": "~0.0.1"
     },
     "mbed-os": {
-      "mbed-drivers": "*",
-      "compiler-polyfill": "^1.2.1"
+      "mbed-drivers": "*"
     }
   }
 }
\ No newline at end of file

--- a/source/DiscoveredCharacteristic.cpp	Mon Jan 11 08:52:00 2016 +0000
+++ b/source/DiscoveredCharacteristic.cpp	Mon Jan 11 08:52:01 2016 +0000
@@ -151,17 +151,12 @@
     return error;
 }
 
-ble_error_t DiscoveredCharacteristic::discoverDescriptors(
-    const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& onCharacteristicDiscovered, 
-    const CharacteristicDescriptorDiscovery::TerminationCallback_t& onTermination) const {
+ble_error_t
+DiscoveredCharacteristic::discoverDescriptors(DescriptorCallback_t callback, const UUID &matchingUUID) const
+{
+    /* Avoid compiler warnings */
+    (void) callback;
+    (void) matchingUUID;
 
-    if(!gattc) {
-        return BLE_ERROR_INVALID_STATE;
-    }
-
-    ble_error_t err = gattc->discoverCharacteristicDescriptors(
-        *this, onCharacteristicDiscovered, onTermination
-    );
-
-    return err;
+    return BLE_ERROR_NOT_IMPLEMENTED; /* TODO: this needs to be filled in. */
 }
\ No newline at end of file