TinyCTSServerArduinoBLE.h

Go to the documentation of this file.

 
#pragma once
#include "TinyCTSArduinoBLE.h"
#include "../TinyCTSServerBase.h"
 
namespace tiny_cts {

class TinyCTSServer : public TinyCTSServerBase {
 public:
  TinyCTSServer() = default;

  bool begin(TinyCTSTimeSource& source, const char* deviceName = "TinyCTS") {
    _source = &source;
    if (!ctsArduinoBleBegin()) return false;
    instance() = this;
    if (_service == nullptr) {
      uint16_t encryption = _settable && _encrypted ? BLEEncryption : 0;
      uint16_t write = _settable ? BLEWrite : 0;
      _service = new BLEService("1805");
      _current = new BLECharacteristic("2A2B", BLERead | BLENotify | write | encryption,
                                       TinyCTSCurrentTime::Size);
      _local = new BLECharacteristic("2A0F", BLERead | write | encryption,
                                     TinyCTSLocalTimeInfo::Size);
      _reference = new BLECharacteristic("2A14", BLERead, TinyCTSReferenceTimeInfo::Size);
      _current->setEventHandler(BLERead, onReadCurrent);
      if (_settable) {
        _current->setEventHandler(BLEWritten, onWriteCurrent);
        _local->setEventHandler(BLEWritten, onWriteLocal);
      }
      _service->addCharacteristic(*_current);
      _service->addCharacteristic(*_local);
      _service->addCharacteristic(*_reference);
      BLE.addService(*_service);
    }
    updateCurrent(0);
    updateLocal();
    updateReference();
    BLE.setLocalName(deviceName);
    BLE.setDeviceName(deviceName);
    BLE.setAdvertisedService(*_service);
    return BLE.advertise() != 0;
  }

  void end() {
    BLE.stopAdvertise();
    _source = nullptr;
    instance() = nullptr;
  }

  bool process() {
    if (_service == nullptr) return false;
    BLE.poll();
    if (!notifyDue()) return false;
    return notifyTime(0);
  }

  bool notifyTime(uint8_t adjustReason = 0) {
    if (_current == nullptr) return false;
    updateCurrent(adjustReason);
    return true;
  }
 
 protected:
  static TinyCTSServer*& instance() {
    static TinyCTSServer* server = nullptr;
    return server;
  }
 
  void onTimeZoneChanged() override {
    if (_local == nullptr) return;
    updateLocal();
    notifyTime(TinyCTSCurrentTime::TimeZoneChange);
  }
 
  void onReferenceChanged() override {
    if (_reference != nullptr) updateReference();
  }
 
  // the events of ArduinoBLE: plain functions without a context
  static void onReadCurrent(BLEDevice, BLECharacteristic) {
    if (instance() != nullptr) instance()->updateCurrent(0);
  }
 
  static void onWriteCurrent(BLEDevice, BLECharacteristic chr) {
    TinyCTSServer* s = instance();
    if (s == nullptr) return;
    if (s->setTimeFromWrite(chr.value(), chr.valueLength())) {
      s->updateCurrent(TinyCTSCurrentTime::ManualUpdate);
    } else {
      s->updateCurrent(0);  // refused: show the real time again
    }
  }
 
  static void onWriteLocal(BLEDevice, BLECharacteristic chr) {
    TinyCTSServer* s = instance();
    if (s == nullptr) return;
    s->setTimeZoneFromWrite(chr.value(), chr.valueLength());
    s->updateLocal();
    s->updateCurrent(TinyCTSCurrentTime::TimeZoneChange);
  }
 
  // (writing the value notifies the subscribed clients)
  void updateCurrent(uint8_t reason) {
    uint8_t data[TinyCTSCurrentTime::Size];
    _current->writeValue(data, static_cast<int>(currentTimeValue(reason, data)));
  }
 
  void updateLocal() {
    uint8_t data[TinyCTSLocalTimeInfo::Size];
    _local->writeValue(data, static_cast<int>(localTimeValue(data)));
  }
 
  void updateReference() {
    uint8_t data[TinyCTSReferenceTimeInfo::Size];
    _reference->writeValue(data, static_cast<int>(referenceTimeValue(data)));
  }
 
  BLEService* _service = nullptr;
  BLECharacteristic* _current = nullptr;
  BLECharacteristic* _local = nullptr;
  BLECharacteristic* _reference = nullptr;
};
 
}  // namespace tiny_cts