TinyCTSClientBase.h

Go to the documentation of this file.

 
#pragma once
#include <cctype>
#include <cstdint>
#include <ctime>
#include <string>
 
#include "TinyCTSTimeSource.h"
#include "TinyCTSTypes.h"
 
namespace tiny_cts {

class TinyCTSClientBase : public TinyCTSTimeSource {
 public:
  uint64_t getTimeMs() override {
    if (_timeMs == 0) return 0;
    uint32_t now = TINY_CTS_MILLIS();
    _timeMs += static_cast<uint32_t>(now - _lastMillis);
    _lastMillis = now;
    return _timeMs;
  }

  uint32_t getTime() { return static_cast<uint32_t>(getTimeMs() / 1000); }

  std::tm getTm() {
    time_t t = static_cast<time_t>(getTime());
    std::tm tm = {};
    ctsGmtime(t, tm);
    return tm;
  }

  std::tm getLocalTm() {
    time_t t = static_cast<time_t>(getTime()) + _info.utcOffsetMinutes() * 60;
    std::tm tm = {};
    ctsGmtime(t, tm);
    return tm;
  }

  const TinyCTSLocalTimeInfo& getLocalTimeInfo() const { return _info; }

  const TinyCTSReferenceTimeInfo& getReferenceTimeInfo() const { return _ref; }

  const TinyCTSCurrentTime& getCurrentTime() const { return _current; }

  const std::string& getDeviceName() const { return _name; }

  const std::string& getDeviceAddress() const { return _address; }

  void setLocalTimeInfo(const TinyCTSLocalTimeInfo& info) { _info = info; }

  void setTimeIsLocal(bool local) { _timeIsLocal = local; }
 
 protected:
  bool storeCurrentTime(const uint8_t* data, size_t len, uint32_t startMs, uint32_t endMs) {
    TinyCTSCurrentTime t;
    uint64_t ms;
    if (!TinyCTSCurrentTime::decode(data, len, t) || !t.toUnixMs(ms)) return false;
    if (_timeIsLocal) ms -= static_cast<int64_t>(_info.utcOffsetMinutes()) * 60000;
    _current = t;
    _timeMs = ms + static_cast<uint32_t>(endMs - startMs) / 2;
    _lastMillis = endMs;
    return true;
  }
 
  void storeLocalInfo(const uint8_t* data, size_t len) {
    TinyCTSLocalTimeInfo::decode(data, len, _info);
  }
 
  void storeReferenceInfo(const uint8_t* data, size_t len) {
    TinyCTSReferenceTimeInfo::decode(data, len, _ref);
  }

  size_t timeToWrite(uint64_t unixMs, uint8_t* out) const {
    if (_timeIsLocal) unixMs += static_cast<int64_t>(_info.utcOffsetMinutes()) * 60000;
    return TinyCTSCurrentTime::fromUnixMs(unixMs, TinyCTSCurrentTime::ManualUpdate).encode(out);
  }

  bool isWanted(const std::string& address, const std::string& name) const {
    return equalsIgnoreCase(address, _device) || name == _device;
  }
 
  static bool equalsIgnoreCase(const std::string& a, const std::string& b) {
    if (a.size() != b.size()) return false;
    for (size_t i = 0; i < a.size(); i++) {
      if (tolower(a[i]) != tolower(b[i])) return false;
    }
    return true;
  }
 
  std::string _device, _name, _address;
  uint64_t _timeMs = 0;
  uint32_t _lastMillis = 0;
  bool _timeIsLocal = false;
  TinyCTSCurrentTime _current;
  TinyCTSLocalTimeInfo _info;
  TinyCTSReferenceTimeInfo _ref;
};
 
}  // namespace tiny_cts