TinyCTSClientDesktop.h

Go to the documentation of this file.

 
#pragma once
#include "TinyCTSBackend.h"
#include "../TinyCTSClientBase.h"
 
namespace tiny_cts {

class TinyCTSClient : public TinyCTSClientBase {
 public:
  explicit TinyCTSClient(const char* device = nullptr, uint32_t scanMs = 5000)
      : _scanMs(scanMs) {
    if (device != nullptr) _device = device;
  }

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

  bool begin() { return update(); }

  bool update() {
    if (!connect()) return false;
    bool ok = false;
    std::vector<uint8_t> data;
    std::string ignored;
    if (_central->read(CTS_LOCAL_TIME_INFO_UUID, data, ignored)) {
      storeLocalInfo(data.data(), data.size());
    }
    if (_central->read(CTS_REFERENCE_TIME_INFO_UUID, data, ignored)) {
      storeReferenceInfo(data.data(), data.size());
    }
    uint32_t t0 = TINY_CTS_MILLIS();
    if (!_central->read(CTS_CURRENT_TIME_UUID, data, _error)) {
      _error = "cannot read the time: " + _error;
    } else {
      _roundTripMs = static_cast<uint32_t>(TINY_CTS_MILLIS() - t0);
      ok = storeCurrentTime(data.data(), data.size(), t0, t0 + _roundTripMs);
      if (!ok) _error = "the device does not know the time";
    }
    _central->disconnect();
    return ok;
  }

  bool setTimeMs(uint64_t unixMs) override {
    uint32_t start = TINY_CTS_MILLIS();
    if (!connect()) return false;
    // the round trip time of a read: the write needs about half of it
    std::vector<uint8_t> data;
    std::string ignored;
    uint32_t t0 = TINY_CTS_MILLIS();
    _central->read(CTS_CURRENT_TIME_UUID, data, ignored);
    _roundTripMs = static_cast<uint32_t>(TINY_CTS_MILLIS() - t0);
    uint8_t out[TinyCTSCurrentTime::Size];
    size_t len = timeToWrite(
        unixMs + static_cast<uint32_t>(TINY_CTS_MILLIS() - start) + _roundTripMs / 2, out);
    bool ok = _central->write(CTS_CURRENT_TIME_UUID, out, len, _error);
    if (!ok) _error = "rejected: " + _error;
    _central->disconnect();
    return ok;
  }

  bool setTimeZone(const TinyCTSLocalTimeInfo& info) {
    if (!connect()) return false;
    uint8_t out[TinyCTSLocalTimeInfo::Size];
    info.encode(out);
    bool ok = _central->write(CTS_LOCAL_TIME_INFO_UUID, out, sizeof out, _error);
    if (!ok) _error = "rejected: " + _error;
    _central->disconnect();
    return ok;
  }

  std::vector<TinyCTSScanEntry> scan(uint32_t timeoutMs) {
    std::vector<TinyCTSScanEntry> result;
    _error.clear();
    if (central()) _central->scan(timeoutMs, result, _error);
    return result;
  }

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

  uint32_t getRoundTripMs() const { return _roundTripMs; }
 
 protected:
  TinyCTSCentral* central() {
    if (!_central) _central = ctsCreateCentral(_adapterName);
    if (!_central) _error = "no Bluetooth stack";
    return _central.get();
  }
 
  bool connect() {
    _error.clear();
    if (central() == nullptr) return false;
    TinyCTSScanEntry found;
    if (!_central->connect(_device, _scanMs, found, _error)) return false;
    _name = found.name;
    _address = found.address;
    return true;
  }
 
  uint32_t _scanMs;
  uint32_t _roundTripMs = 0;
  std::string _adapterName = "hci0";
  std::string _error;
  std::unique_ptr<TinyCTSCentral> _central;
};
 
}  // namespace tiny_cts