Microbug
Minor temporary patch to allow DFU packet callback
Fork of
BLE_API
by 
Bluetooth Low Energy
Diff: services/URIBeaconConfigService.h
- Revision:
- 209:c92872ad8935
- Parent:
- 208:88a3a58769bf
- Child:
- 210:0c14030d1bd0
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/services/URIBeaconConfigService.h Mon Dec 01 14:31:18 2014 +0000
@@ -0,0 +1,377 @@
+/* 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 __BLE_URI_BEACON_CONFIG_SERVICE_H__
+#define __BLE_URI_BEACON_CONFIG_SERVICE_H__
+
+#include "BLEDevice.h"
+
+#define UUID_INITIALIZER_LIST(FIRST, SECOND) { \
+ 0xee, 0x0c, FIRST, SECOND, 0x87, 0x86, 0x40, 0xba, \
+ 0xab, 0x96, 0x99, 0xb9, 0x1a, 0xc9, 0x81, 0xd8, \
+}
+const uint8_t URIBeacon2ControlServiceUUID[] = UUID_INITIALIZER_LIST(0x20, 0x80);
+const uint8_t lockedStateCharUUID[] = UUID_INITIALIZER_LIST(0x20, 0x81);
+const uint8_t uriDataCharUUID[] = UUID_INITIALIZER_LIST(0x20, 0x84);
+const uint8_t flagsCharUUID[] = UUID_INITIALIZER_LIST(0x20, 0x85);
+const uint8_t txPowerLevelsCharUUID[] = UUID_INITIALIZER_LIST(0x20, 0x86);
+const uint8_t beaconPeriodCharUUID[] = UUID_INITIALIZER_LIST(0x20, 0x88);
+const uint8_t resetCharUUID[] = UUID_INITIALIZER_LIST(0x20, 0x89);
+
+class URIBeaconConfigService {
+public:
+ enum TXPowerModes_t {
+ TX_POWER_MODE_LOWEST = 0,
+ TX_POWER_MODE_LOW = 1,
+ TX_POWER_MODE_MEDIUM = 2,
+ TX_POWER_MODE_HIGH = 3,
+ NUM_POWER_MODES
+ };
+
+ /**
+ * @param[ref] ble
+ * BLEDevice object for the underlying controller.
+ * @param[in] uridata
+ * URI as a null-terminated string.
+ * @param[in] flagsIn
+ * UriBeacon Flags.
+ * @param[in] effectiveTxPowerIn
+ * UriBeacon Tx Power Level in dBm.
+ * @param[in] beaconPeriodIn
+ * The period in milliseconds that a UriBeacon packet is
+ * transmitted. A value of zero disables UriBeacon
+ * transmissions.
+ */
+ URIBeaconConfigService(BLEDevice &bleIn, const char *uriDataIn, uint8_t flagsIn = 0, int8_t effectiveTxPowerIn = 0, uint16_t beaconPeriodIn = 1000) :
+ ble(bleIn),
+ payloadIndex(0),
+ serviceDataPayload(),
+ initSucceeded(false),
+ lockedState(false),
+ uriDataLength(0),
+ uriData(),
+ flags(flagsIn),
+ effectiveTxPower(effectiveTxPowerIn),
+ powerLevels(),
+ beaconPeriod(beaconPeriodIn),
+ lockedStateChar(lockedStateCharUUID, reinterpret_cast<uint8_t *>(&lockedState), 1, 1, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ),
+ uriDataChar(uriDataCharUUID,
+ uriData,
+ MAX_SIZE_URI_DATA_CHAR_VALUE,
+ MAX_SIZE_URI_DATA_CHAR_VALUE,
+ GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE),
+ flagsChar(flagsCharUUID, &flags, 1, 1, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE),
+ txPowerLevelsChar(txPowerLevelsCharUUID,
+ reinterpret_cast<uint8_t *>(powerLevels),
+ NUM_POWER_MODES * sizeof(int8_t),
+ NUM_POWER_MODES * sizeof(int8_t),
+ GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE),
+ beaconPeriodChar(beaconPeriodCharUUID, reinterpret_cast<uint8_t *>(&beaconPeriod), 2, 2,
+ GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE),
+ resetChar(resetCharUUID, reinterpret_cast<uint8_t *>(&resetFlag), 1, 1,
+ GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE)
+ {
+ if ((uriDataIn == NULL) || ((uriDataLength = strlen(uriDataIn)) == 0) || (uriDataLength > MAX_SIZE_URI_DATA_CHAR_VALUE)) {
+ return;
+ }
+ strcpy(reinterpret_cast<char *>(uriData), uriDataIn);
+
+ configure();
+ if (initSucceeded) {
+ saveDefaults();
+ }
+
+ GattCharacteristic *charTable[] = {&lockedStateChar, &uriDataChar, &flagsChar, &txPowerLevelsChar, &beaconPeriodChar, &resetChar};
+ GattService beaconControlService(URIBeacon2ControlServiceUUID, charTable, sizeof(charTable) / sizeof(GattCharacteristic *));
+
+ ble.addService(beaconControlService);
+ ble.onDataWritten(this, &URIBeaconConfigService::onDataWritten);
+ }
+
+ bool configuredSuccessfully(void) const {
+ return initSucceeded;
+ }
+
+ /**
+ * Please note that the following public APIs are offered to allow modifying
+ * the service programmatically. It is also possible to do so over BLE GATT
+ * transactions.
+ */
+public:
+ /**
+ * Update flags of the URIBeacon dynamically.
+ *
+ * @param[in] flagsIn
+ *
+ * ### UriBeacon Flags
+ * Bit | Description
+ * :---- | :----------
+ * 0 | Invisible Hint
+ * 1..7 | Reserved for future use. Must be zero.
+ *
+ * The `Invisible Hint` flag is a command for the user-agent that tells
+ * it not to access or display the UriBeacon. This is a guideline only,
+ * and is not a blocking method. User agents may, with user approval,
+ * display invisible beacons.
+ */
+ void setFlags(uint8_t flagsIn) {
+ flags = flagsIn;
+ configure();
+ }
+
+ /**
+ * Update the txPower for a particular mode in the powerLevels table.
+ */
+ void setTxPowerLevel(TXPowerModes_t mode, int8_t txPowerIn) {
+ powerLevels[mode] = txPowerIn;
+ }
+
+ /**
+ * Set the effective power mode from one of the values in the powerLevels tables.
+ */
+ void useTxPowerMode(TXPowerModes_t mode) {
+ effectiveTxPower = powerLevels[mode];
+ configure();
+ }
+
+ /**
+ * The period in milliseconds that a UriBeacon packet is transmitted.
+ *
+ * @Note: A value of zero disables UriBeacon transmissions.
+ */
+ void setBeaconPeriod(uint16_t beaconPeriodIn) {
+ beaconPeriod = beaconPeriodIn;
+ configure();
+ }
+
+private:
+ /**
+ * Setup the advertisement payload and GAP settings.
+ */
+ void configure(void) {
+ const uint8_t BEACON_UUID[] = {0xD8, 0xFE};
+
+ payloadIndex = 0;
+ serviceDataPayload[payloadIndex++] = BEACON_UUID[0];
+ serviceDataPayload[payloadIndex++] = BEACON_UUID[1];
+ serviceDataPayload[payloadIndex++] = flags;
+ serviceDataPayload[payloadIndex++] = effectiveTxPower;
+
+ const char *urlData = reinterpret_cast<char *>(uriData);
+ size_t sizeofURLData = uriDataLength;
+ size_t encodedBytes = encodeURISchemePrefix(urlData, sizeofURLData) + encodeURI(urlData, sizeofURLData);
+
+ ble.clearAdvertisingPayload();
+ ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, BEACON_UUID, sizeof(BEACON_UUID));
+ ble.accumulateAdvertisingPayload(GapAdvertisingData::SERVICE_DATA, serviceDataPayload, encodedBytes + 4);
+
+ ble.setAdvertisingInterval(Gap::MSEC_TO_ADVERTISEMENT_DURATION_UNITS(beaconPeriod));
+ ble.setTxPower(effectiveTxPower);
+ }
+
+ size_t encodeURISchemePrefix(const char *&urldata, size_t &sizeofURLData) {
+ const char *prefixes[] = {
+ "http://www.",
+ "https://www.",
+ "http://",
+ "https://",
+ "urn:uuid:"
+ };
+
+ size_t encodedBytes = 0;
+ const size_t NUM_PREFIXES = sizeof(prefixes) / sizeof(char *);
+ for (unsigned i = 0; i < NUM_PREFIXES; i++) {
+ size_t prefixLen = strlen(prefixes[i]);
+ if (strncmp(urldata, prefixes[i], prefixLen) == 0) {
+ serviceDataPayload[payloadIndex++] = i;
+ encodedBytes = 1;
+
+ urldata += prefixLen;
+ sizeofURLData -= prefixLen;
+ break;
+ }
+ }
+
+ return encodedBytes;
+ }
+
+ size_t encodeURI(const char *urldata, size_t sizeofURLData) {
+ const char *suffixes[] = {
+ ".com/",
+ ".org/",
+ ".edu/",
+ ".net/",
+ ".info/",
+ ".biz/",
+ ".gov/",
+ ".com",
+ ".org",
+ ".edu",
+ ".net",
+ ".info",
+ ".biz",
+ ".gov"
+ };
+ const size_t NUM_SUFFIXES = sizeof(suffixes) / sizeof(char *);
+
+ size_t encodedBytes = 0;
+ while (sizeofURLData && (payloadIndex < MAX_SIZEOF_SERVICE_DATA_PAYLOAD)) {
+ /* check for suffix match */
+ unsigned i;
+ for (i = 0; i < NUM_SUFFIXES; i++) {
+ size_t suffixLen = strlen(suffixes[i]);
+ if ((suffixLen == 0) || (sizeofURLData < suffixLen)) {
+ continue;
+ }
+
+ if (strncmp(urldata, suffixes[i], suffixLen) == 0) {
+ serviceDataPayload[payloadIndex++] = i;
+ ++encodedBytes;
+ urldata += suffixLen;
+ sizeofURLData -= suffixLen;
+ break; /* from the for loop for checking against suffixes */
+ }
+ }
+ /* This is the default case where we've got an ordinary character which doesn't match a suffix. */
+ if (i == NUM_SUFFIXES) {
+ serviceDataPayload[payloadIndex++] = *urldata;
+ ++encodedBytes;
+ ++urldata;
+ --sizeofURLData;
+ }
+ }
+ if (sizeofURLData == 0) {
+ initSucceeded = true;
+ }
+
+ return encodedBytes;
+ }
+
+ void onDataWritten(const GattCharacteristicWriteCBParams *params) {
+ if (params->charHandle == uriDataChar.getValueAttribute().getHandle()) {
+ if (lockedState) { /* When locked, the device isn't allowed to update the uriData characteristic. */
+ /* Restore GATT database with previous value. */
+ ble.updateCharacteristicValue(uriDataChar.getValueAttribute().getHandle(), uriData, uriDataLength);
+ return;
+ }
+
+ /* We don't handle very large writes at the moment. */
+ if ((params->offset != 0) || (params->len > MAX_SIZE_URI_DATA_CHAR_VALUE)) {
+ return;
+ }
+
+ uriDataLength = params->len;
+ memcpy(uriData, params->data, uriDataLength);
+ } else if (params->charHandle == flagsChar.getValueAttribute().getHandle()) {
+ if (lockedState) { /* When locked, the device isn't allowed to update the characteristic. */
+ /* Restore GATT database with previous value. */
+ ble.updateCharacteristicValue(flagsChar.getValueAttribute().getHandle(), &flags, 1 /* size */);
+ return;
+ } else {
+ flags = *(params->data);
+ }
+ } else if (params->charHandle == txPowerLevelsChar.getValueAttribute().getHandle()) {
+ if (lockedState) { /* When locked, the device isn't allowed to update the characteristic. */
+ /* Restore GATT database with previous value. */
+ ble.updateCharacteristicValue(txPowerLevelsChar.getValueAttribute().getHandle(), reinterpret_cast<uint8_t *>(powerLevels), NUM_POWER_MODES * sizeof(int8_t));
+ return;
+ } else {
+ memcpy(powerLevels, params->data, NUM_POWER_MODES * sizeof(int8_t));
+ }
+ } else if (params->charHandle == beaconPeriodChar.getValueAttribute().getHandle()) {
+ if (lockedState) { /* When locked, the device isn't allowed to update the characteristic. */
+ /* Restore GATT database with previous value. */
+ ble.updateCharacteristicValue(beaconPeriodChar.getValueAttribute().getHandle(), reinterpret_cast<uint8_t *>(&beaconPeriod), sizeof(uint16_t));
+ return;
+ } else {
+ beaconPeriod = *((uint16_t *)(params->data));
+ }
+ } else if (params->charHandle == resetChar.getValueAttribute().getHandle()) {
+ resetDefaults();
+ }
+ configure();
+ ble.setAdvertisingPayload();
+ }
+
+ /* Preserve the defaults to be able to reset() upon request. */
+ void saveDefaults(void) {
+ memcpy(defaultURIData, uriData, MAX_SIZE_URI_DATA_CHAR_VALUE);
+ defaultFlags = flags;
+ defaultEffectiveTxPower = effectiveTxPower;
+ defaultBeaconPeriod = beaconPeriod;
+ }
+
+ void resetDefaults(void) {
+ memcpy(uriData, defaultURIData, MAX_SIZE_URI_DATA_CHAR_VALUE);
+ memset(powerLevels, 0, sizeof(powerLevels));
+ flags = defaultFlags;
+ effectiveTxPower = defaultEffectiveTxPower;
+ beaconPeriod = defaultBeaconPeriod;
+
+ ble.updateCharacteristicValue(uriDataChar.getValueAttribute().getHandle(), uriData, uriDataLength);
+ ble.updateCharacteristicValue(flagsChar.getValueAttribute().getHandle(), &flags, 1 /* size */);
+ ble.updateCharacteristicValue(beaconPeriodChar.getValueAttribute().getHandle(), reinterpret_cast<uint8_t *>(&beaconPeriod), sizeof(uint16_t));
+
+ configure();
+ }
+
+private:
+ /**
+ * For debugging only.
+ */
+ void dumpEncodedSeviceData() const {
+ printf("encoded: '");
+ for (unsigned i = 0; i < payloadIndex; i++) {
+ printf(" %02x", serviceDataPayload[i]);
+ }
+ printf("'\r\n");
+ }
+
+private:
+ static const size_t MAX_SIZEOF_SERVICE_DATA_PAYLOAD = 18; /* Uri Data must be between 0 and 18 bytes in length. */
+ static const size_t MAX_SIZE_URI_DATA_CHAR_VALUE = 48; /* This is chosen arbitrarily. It should be large enough
+ * to hold any reasonable uncompressed URI. */
+
+private:
+ BLEDevice &ble;
+
+ size_t payloadIndex;
+ uint8_t serviceDataPayload[MAX_SIZEOF_SERVICE_DATA_PAYLOAD];
+ bool initSucceeded;
+
+ bool lockedState;
+ uint16_t uriDataLength;
+ uint8_t uriData[MAX_SIZE_URI_DATA_CHAR_VALUE];
+ uint8_t flags;
+ int8_t effectiveTxPower;
+ int8_t powerLevels[NUM_POWER_MODES];
+ uint16_t beaconPeriod;
+ bool resetFlag;
+
+ uint8_t defaultURIData[MAX_SIZE_URI_DATA_CHAR_VALUE];
+ uint8_t defaultFlags;
+ int8_t defaultEffectiveTxPower;
+ uint16_t defaultBeaconPeriod;
+
+ GattCharacteristic lockedStateChar;
+ GattCharacteristic uriDataChar;
+ GattCharacteristic flagsChar;
+ GattCharacteristic txPowerLevelsChar;
+ GattCharacteristic beaconPeriodChar;
+ GattCharacteristic resetChar;
+};
+
+#endif /* #ifndef __BLE_URI_BEACON_CONFIG_SERVICE_H__*/
\ No newline at end of file