TinyCTSServerBase.h

Go to the documentation of this file.

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

class TinyCTSServerBase {
 public:
  virtual ~TinyCTSServerBase() = default;

  void setNotifyInterval(uint32_t ms) { _notifyMs = ms; }

  void setTimeZone(int utcOffsetMinutes, int dstMinutes = 0) {
    _info = TinyCTSLocalTimeInfo::fromMinutes(utcOffsetMinutes, dstMinutes);
    onTimeZoneChanged();
  }

  void setReferenceInfo(uint8_t source, uint8_t accuracy = 255) {
    _ref.source = source;
    _ref.accuracy = accuracy;
    onReferenceChanged();
  }

  void setTimeIsLocal(bool local) { _timeIsLocal = local; }

  void enableTimeSetting(bool requireEncryption = true) {
    _settable = true;
    _encrypted = requireEncryption;
  }

  uint32_t getTimeSetCount() const { return _setCount; }
 
 protected:
  virtual void onTimeZoneChanged() {}
  virtual void onReferenceChanged() {}

  size_t currentTimeValue(uint8_t reason, uint8_t* out) {
    uint64_t ms = _source != nullptr ? _source->getTimeMs() : 0;
    TinyCTSCurrentTime t;
    if (ms != 0) {
      if (_timeIsLocal) ms += static_cast<int64_t>(_info.utcOffsetMinutes()) * 60000;
      t = TinyCTSCurrentTime::fromUnixMs(ms, reason);
    }
    return t.encode(out);
  }
 
  size_t localTimeValue(uint8_t* out) const { return _info.encode(out); }
 
  size_t referenceTimeValue(uint8_t* out) const { return _ref.encode(out); }

  bool setTimeFromWrite(const uint8_t* data, size_t len) {
    TinyCTSCurrentTime t;
    uint64_t ms;
    if (_source == nullptr || !_settable) return false;
    if (!TinyCTSCurrentTime::decode(data, len, t) || !t.toUnixMs(ms)) return false;
    if (_timeIsLocal) ms -= static_cast<int64_t>(_info.utcOffsetMinutes()) * 60000;
    if (!_source->setTimeMs(ms)) return false;
    _setCount++;
    return true;
  }

  bool setTimeZoneFromWrite(const uint8_t* data, size_t len) {
    TinyCTSLocalTimeInfo info;
    if (!_settable || !TinyCTSLocalTimeInfo::decode(data, len, info)) return false;
    _info = info;
    return true;
  }

  bool notifyDue() {
    if (_source == nullptr || _notifyMs == 0) return false;
    uint32_t now = TINY_CTS_MILLIS();
    if (static_cast<uint32_t>(now - _lastNotify) < _notifyMs) return false;
    _lastNotify = now;
    return true;
  }
 
  TinyCTSTimeSource* _source = nullptr;
  TinyCTSLocalTimeInfo _info;
  TinyCTSReferenceTimeInfo _ref;
  uint32_t _notifyMs = 0;
  uint32_t _lastNotify = 0;
  uint32_t _setCount = 0;
  bool _timeIsLocal = false;
  bool _settable = false;
  bool _encrypted = true;
};
 
}  // namespace tiny_cts