BLEDevice.cpp

/*
  This file is part of the ArduinoBLE library.
  Copyright (c) 2018 Arduino SA. All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "utility/ATT.h"
#include "utility/BLEUuid.h"
#include "utility/HCI.h"

#include "remote/BLERemoteDevice.h"

#include "BLEDevice.h"

extern "C" int strcasecmp(char const *a, char const *b);

BLEDevice::BLEDevice() :
  _advertisementTypeMask(0),
  _eirDataLength(0),
  _rssi(127)
{
  memset(_address, 0x00, sizeof(_address));
}

BLEDevice::BLEDevice(uint8_t addressType, uint8_t address[6]) :
  _addressType(addressType),
  _advertisementTypeMask(0),
  _eirDataLength(0),
  _rssi(127)
{
  memcpy(_address, address, sizeof(_address));
}

BLEDevice::~BLEDevice()
{
}

void BLEDevice::poll()
{
  HCI.poll();
}

void BLEDevice::poll(unsigned long timeout)
{
  HCI.poll(timeout);
}

bool BLEDevice::connected() const
{
  HCI.poll();

  if (!(*this)) {
    return false;
  }

  return ATT.connected(_addressType, _address);
}

bool BLEDevice::disconnect()
{
  return ATT.disconnect(_addressType, _address);
}

String BLEDevice::address() const
{
  char result[18];
  sprintf(result, "%02x:%02x:%02x:%02x:%02x:%02x", _address[5], _address[4], _address[3], _address[2], _address[1], _address[0]);

  return result;
}

bool BLEDevice::hasLocalName() const
{
  return (localName().length() > 0);
}

bool BLEDevice::hasAdvertisedServiceUuid() const
{
  return hasAdvertisedServiceUuid(0);
}

bool BLEDevice::hasAdvertisedServiceUuid(int index) const
{
  return (advertisedServiceUuid(index).length() > 0);
}

int BLEDevice::advertisedServiceUuidCount() const
{
  int advertisedServiceCount = 0;

  for (unsigned char i = 0; i < _eirDataLength;) {
    int eirLength = _eirData[i++];
    int eirType = _eirData[i++];

    if (eirType == 0x02 || eirType == 0x03 || eirType == 0x06 || eirType == 0x07) {
      int uuidLength;

      if (eirType == 0x02 || eirType == 0x03) {
        uuidLength = 2;
      } else /*if (eirType == 0x06 || eirType == 0x07)*/ {
        uuidLength = 16;
      }

      for (int j = 0; j < (eirLength - 1); j += uuidLength) {
        advertisedServiceCount++;
      }
    }

    i += (eirLength - 1);
  }

  return advertisedServiceCount;
}

String BLEDevice::localName() const
{
  String localName = "";

  for (int i = 0; i < _eirDataLength;) {
    int eirLength = _eirData[i++];
    int eirType = _eirData[i++];

    if (eirType == 0x08 || eirType == 0x09) {
      localName.reserve(eirLength - 1);

      for (int j = 0; j < (eirLength - 1); j++) {
        localName += (char)_eirData[i + j];
      }
      break;
    }

    i += (eirLength - 1);
  }

  return localName;
}

String BLEDevice::advertisedServiceUuid() const
{
  return advertisedServiceUuid(0);
}

String BLEDevice::advertisedServiceUuid(int index) const
{
  String serviceUuid;
  int uuidIndex = 0;

  for (unsigned char i = 0; i < _eirDataLength;) {
    int eirLength = _eirData[i++];
    int eirType = _eirData[i++];

    if (eirType == 0x02 || eirType == 0x03 || eirType == 0x06 || eirType == 0x07) {
      int uuidLength;

      if (eirType == 0x02 || eirType == 0x03) {
        uuidLength = 2;
      } else /*if (eirType == 0x06 || eirType == 0x07)*/ {
        uuidLength = 16;
      }

      for (int j = 0; j < (eirLength - 1); j += uuidLength) {
        if (uuidIndex == index) {
          serviceUuid = BLEUuid::uuidToString(&_eirData[i + j * uuidLength], uuidLength);
        }

        uuidIndex++;
      }
    }

    i += (eirLength - 1);
  }

  return serviceUuid;
}

bool BLEDevice::hasAdvertisementData() const
{
  return (_eirDataLength > 0);
}

int BLEDevice::advertisementDataLength() const
{
  return _eirDataLength;
}

int BLEDevice::advertisementData(uint8_t value[], int length) const
{
  if (length > _eirDataLength) length = _eirDataLength;

  if (length) {
    memcpy(value, _eirData, length);
  }

  return length;
}

bool BLEDevice::hasManufacturerData() const
{
  return (manufacturerDataLength() > 0);
}

int BLEDevice::manufacturerDataLength() const
{
  int length = 0;

  for (int i = 0; i < _eirDataLength;) {
    int eirLength = _eirData[i++];
    int eirType = _eirData[i++];

    if (eirType == 0xFF) {
      length = (eirLength - 1);
      break;
    }

    i += (eirLength - 1);
  }

  return length;
}

int BLEDevice::manufacturerData(uint8_t value[], int length) const
{
  for (int i = 0; i < _eirDataLength;) {
    int eirLength = _eirData[i++];
    int eirType = _eirData[i++];

    if (eirType == 0xFF) {
      if (length > (eirLength - 1)) length = (eirLength - 1);

      memcpy(value, &_eirData[i], length);
      break;
    }

    i += (eirLength - 1);
  }

  return length;
}

int BLEDevice::rssi()
{
  uint16_t handle = ATT.connectionHandle(_addressType, _address);

  if (handle != 0xffff) {
    return HCI.readRssi(handle);
  }

  return _rssi;
}

bool BLEDevice::connect()
{
  return ATT.connect(_addressType, _address);
}

bool BLEDevice::discoverAttributes()
{
  return ATT.discoverAttributes(_addressType, _address, NULL);
}

bool BLEDevice::discoverService(const char* serviceUuid)
{
  return ATT.discoverAttributes(_addressType, _address, serviceUuid);
}

BLEDevice::operator bool() const
{
  uint8_t zeros[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,};

  return (memcmp(_address, zeros, sizeof(zeros)) != 0);
}

bool BLEDevice::operator==(const BLEDevice& rhs) const
{
  return ((_addressType == rhs._addressType) && memcmp(_address, rhs._address, sizeof(_address)) == 0);
}

bool BLEDevice::operator!=(const BLEDevice& rhs) const
{
  return ((_addressType != rhs._addressType) || memcmp(_address, rhs._address, sizeof(_address)) != 0);
}

String BLEDevice::deviceName()
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    BLEService genericAccessService = service("1800");

    if (genericAccessService) {
      BLECharacteristic deviceNameCharacteristic = genericAccessService.characteristic("2a00");

      if (deviceNameCharacteristic) {
        deviceNameCharacteristic.read();

        String result;
        int valueLength = deviceNameCharacteristic.valueLength();
        const char* value = (const char*)deviceNameCharacteristic.value();

        result.reserve(valueLength);

        for (int i = 0; i < valueLength; i++) {
          result += value[i];
        }

        return result;
      }
    }
  }

  return "";
}

int BLEDevice::appearance()
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    BLEService genericAccessService = service("1801");

    if (genericAccessService) {
      BLECharacteristic appearanceCharacteristic = genericAccessService.characteristic("2a01");

      if (appearanceCharacteristic) {
        appearanceCharacteristic.read();

        uint16_t result = 0;

        memcpy  (&result, appearanceCharacteristic.value(), min((int)sizeof(result), appearanceCharacteristic.valueLength()));

        return result;
      }
    }
  }

  return 0;
}

int BLEDevice::serviceCount() const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    return device->serviceCount();
  }

  return 0;
}

bool BLEDevice::hasService(const char* uuid) const
{
  return hasService(uuid, 0);
}

bool BLEDevice::hasService(const char* uuid, int index) const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    int count = 0;
    int numServices = device->serviceCount();

    for (int i = 0; i < numServices; i++) {
      BLERemoteService* s = device->service(i);

      if (strcasecmp(uuid, s->uuid()) == 0) {
        if (count == index) {
          return true;
        }

        count++;
      }
    }
  }

  return false;
}

BLEService BLEDevice::service(int index) const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    if (index < (int)device->serviceCount()) {
      return BLEService(device->service(index));
    }
  }

  return BLEService();
}

BLEService BLEDevice::service(const char * uuid) const
{
  return service(uuid, 0);
}

BLEService BLEDevice::service(const char * uuid, int index) const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    int count = 0;
    int numServices = device->serviceCount();

    for (int i = 0; i < numServices; i++) {
      BLERemoteService* s = device->service(i);

      if (strcasecmp(uuid, s->uuid()) == 0) {
        if (count == index) {
          return BLEService(s);
        }

        count++;
      }
    }
  }

  return BLEService();
}

int BLEDevice::characteristicCount() const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    int result = 0;
    int numServices = device->serviceCount();

    for (int i = 0; i < numServices; i++) {
      result += device->service(i)->characteristicCount();
    }

    return result;
  }

  return 0;
}

bool BLEDevice::hasCharacteristic(const char* uuid) const
{
  return hasCharacteristic(uuid, 0);
}

bool BLEDevice::hasCharacteristic(const char* uuid, int index) const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    int count = 0;
    int numServices = device->serviceCount();

    for (int i = 0; i < numServices; i++) {
      BLERemoteService* s = device->service(i);

      int numCharacteristics = s->characteristicCount();

      for (int j = 0; j < numCharacteristics; j++) {
        BLERemoteCharacteristic* c = s->characteristic(j);


        if (strcasecmp(c->uuid(), uuid) == 0) {
          if (count == index) {
            return true;
          }
        }

        count++;
      }
    }
  }

  return false;
}

BLECharacteristic BLEDevice::characteristic(int index) const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    int count = 0;
    int numServices = device->serviceCount();

    for (int i = 0; i < numServices; i++) {
      BLERemoteService* s = device->service(i);

      int numCharacteristics = s->characteristicCount();

      for (int j = 0; j < numCharacteristics; j++) {
        if (count == index) {
          BLERemoteCharacteristic* c = s->characteristic(j);

          return BLECharacteristic(c);
        }

        count++;
      }
    }
  }

  return BLECharacteristic();
}

BLECharacteristic BLEDevice::characteristic(const char * uuid) const
{
  return characteristic(uuid, 0);
}

BLECharacteristic BLEDevice::characteristic(const char * uuid, int index) const
{
  BLERemoteDevice* device = ATT.device(_addressType, _address);

  if (device) {
    int count = 0;
    int numServices = device->serviceCount();

    for (int i = 0; i < numServices; i++) {
      BLERemoteService* s = device->service(i);

      int numCharacteristics = s->characteristicCount();

      for (int j = 0; j < numCharacteristics; j++) {
        BLERemoteCharacteristic* c = s->characteristic(j);

        if (strcasecmp(c->uuid(), uuid) == 0) {
          if (count == index) {

            return BLECharacteristic(c);
          }

          count++;
        }
      }
    }
  }

  return BLECharacteristic();
}

bool BLEDevice::hasAddress(uint8_t addressType, uint8_t address[6])
{
  return (_addressType == addressType) && (memcmp(_address, address, sizeof(_address)) == 0);
}

void BLEDevice::setAdvertisementData(uint8_t type, uint8_t eirDataLength, uint8_t eirData[], int8_t rssi)
{
  _advertisementTypeMask = (1 << type);
  _eirDataLength = eirDataLength;
  memcpy(_eirData, eirData, eirDataLength);
  _rssi = rssi;
}

void BLEDevice::setScanResponseData(uint8_t eirDataLength, uint8_t eirData[], int8_t rssi)
{
  _advertisementTypeMask |= (1 << 0x04);
  memcpy(&_eirData[_eirDataLength], eirData, eirDataLength);
  _eirDataLength += eirDataLength;
  _rssi = rssi;
}

bool BLEDevice::discovered()
{
  // expect, 0x03 or 0x04 flag to be set
  return (_advertisementTypeMask & 0x18) != 0;
}