TinyCTSServerDesktop.h

Go to the documentation of this file.

 
#pragma once
#include <mutex>
 
#include "TinyCTSBackend.h"
#include "../TinyCTSServerBase.h"
 
namespace tiny_cts {

class TinyCTSServer : public TinyCTSServerBase, private TinyCTSPeripheralHandler {
 public:
  TinyCTSServer() = default;
  ~TinyCTSServer() override { end(); }

  void setAdapter(const char* name) { _adapterName = name; }

  bool begin(TinyCTSTimeSource& source, const char* deviceName = "TinyCTS") {
    std::lock_guard<std::recursive_mutex> lock(_mutex);
    _source = &source;
    _error.clear();
    _peripheral = ctsCreatePeripheral(_adapterName);
    if (!_peripheral) {
      _error = "no Bluetooth stack";
      return false;
    }
    if (!_peripheral->start(deviceName, _settable, _encrypted, this, _error)) {
      _peripheral.reset();
      return false;
    }
    return true;
  }

  void end() {
    std::lock_guard<std::recursive_mutex> lock(_mutex);
    if (_peripheral) _peripheral->stop();
    _peripheral.reset();
    _source = nullptr;
  }

  bool process() {
    {
      std::lock_guard<std::recursive_mutex> lock(_mutex);
      if (!_peripheral) return false;
      _peripheral->process();
      if (!notifyDue()) return false;
    }
    return notifyTime(0);
  }

  bool notifyTime(uint8_t adjustReason = 0) {
    std::lock_guard<std::recursive_mutex> lock(_mutex);
    if (!_peripheral) return false;
    uint8_t data[TinyCTSCurrentTime::Size];
    size_t len = currentTimeValue(adjustReason, data);
    _peripheral->notify(CTS_CURRENT_TIME_UUID, std::vector<uint8_t>(data, data + len));
    return true;
  }

  const std::string& getLastError() const { return _error; }

  uint32_t getRequestCount() const { return _requests; }
 
 protected:
  void onTimeZoneChanged() override { notifyTime(TinyCTSCurrentTime::TimeZoneChange); }
 
  bool onRead(uint16_t uuid, std::vector<uint8_t>& value) override {
    std::lock_guard<std::recursive_mutex> lock(_mutex);
    value.resize(TinyCTSCurrentTime::Size);
    if (uuid == CTS_CURRENT_TIME_UUID) {
      value.resize(currentTimeValue(0, value.data()));
    } else if (uuid == CTS_LOCAL_TIME_INFO_UUID) {
      value.resize(localTimeValue(value.data()));
    } else if (uuid == CTS_REFERENCE_TIME_INFO_UUID) {
      value.resize(referenceTimeValue(value.data()));
    } else {
      return false;
    }
    _requests++;
    return true;
  }
 
  bool onWrite(uint16_t uuid, const uint8_t* data, size_t len) override {
    std::lock_guard<std::recursive_mutex> lock(_mutex);
    if (uuid == CTS_CURRENT_TIME_UUID && setTimeFromWrite(data, len)) {
      notifyTime(TinyCTSCurrentTime::ManualUpdate);
      return true;
    }
    if (uuid == CTS_LOCAL_TIME_INFO_UUID && setTimeZoneFromWrite(data, len)) {
      notifyTime(TinyCTSCurrentTime::TimeZoneChange);
      return true;
    }
    return false;
  }
 
  std::string _adapterName = "hci0", _error;
  std::unique_ptr<TinyCTSPeripheral> _peripheral;
  std::recursive_mutex _mutex;
  uint32_t _requests = 0;
};
 
}  // namespace tiny_cts