client.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <vector>
 
#include "roo_collections.h"
#include "roo_collections/flat_small_hash_map.h"
#include "roo_collections/flat_small_hash_set.h"
#include "roo_threads.h"
#include "roo_threads/mutex.h"
#include "roo_transceivers.h"
#include "roo_transceivers/id.h"
#include "roo_transceivers/notification.h"
#include "roo_transceivers/universe.h"
 
namespace roo_transceivers {
 
/// Communication channel for UniverseClient.
class UniverseClientChannel {
 public:
  using ServerMessageCb =
      std::function<void(const roo_transceivers_ServerMessage&)>;
 
  virtual ~UniverseClientChannel() = default;
 
  virtual void registerServerMessageCallback(ServerMessageCb cb) = 0;
 
  virtual void sendClientMessage(const roo_transceivers_ClientMessage& msg) = 0;
};
 
/// Universe that mirrors a remote universe via a bidirectional channel.
class UniverseClient : public Universe {
 public:
  struct DeviceEntry {
    DeviceLocator locator;
    int descriptor_key;
  };
 
  UniverseClient(UniverseClientChannel& channel);
 
  ~UniverseClient();
 
  void begin();
 
  size_t deviceCount() const override;
 
  bool forEachDevice(
      std::function<bool(const DeviceLocator&)> callback) const override;
 
  bool getDeviceDescriptor(
      const DeviceLocator& locator,
      roo_transceivers_Descriptor& descriptor) const override;
 
  Measurement read(const SensorLocator& locator) const override;
 
  bool write(const ActuatorLocator& locator, float value) override;
 
  void requestUpdate() override;
 
  void addEventListener(EventListener* listener) override;
 
  void removeEventListener(EventListener* listener) override;
 
 private:
  // Convenience function to lookup a descriptor by device locator. Additionally
  // returns the descriptor key, assigned by the server.
  const roo_transceivers_Descriptor* lookupDeviceDescriptor(
      const DeviceLocator& locator, int& descriptor_key) const;
 
  // Called when a message is received from the server. Returns true on success;
  // false on protocol error. If returns false, the client will attempt to
  // recover by issuing RequestState.
  bool handleServerMessage(const roo_transceivers_ServerMessage& msg);
 
  bool handleInit();
 
  bool handleDescriptorAdded(int key,
                             const roo_transceivers_Descriptor& descriptor);
 
  bool handleDescriptorRemoved(int key);
 
  bool handleDevice(const DeviceLocator& locator, int descriptor_key);
 
  bool handleDeviceAdded(const DeviceLocator& locator, int descriptor_key);
 
  bool handleDeviceRemoved(int prev_index);
 
  bool handleDevicePreserved(int prev_index_first, size_t count);
 
  bool handleDeviceModified(int prev_index, int descriptor_key);
 
  // Helper method to propagate the devices event to listeners.
  void notifyDevicesChanged();
 
  // Helper method to propagate the readings event to listeners.
  void notifyReadingsAvailable();
 
  void clearAll();
 
  bool handleUpdateBegin(bool delta);
 
  bool handleUpdateEnd();
 
  bool handleReadingsBegin();
 
  bool handleReadings(
      const DeviceLocator& device,
      const roo_transceivers_ServerMessage_Reading_SensorValue* readings,
      size_t readings_count);
 
  bool handleReadingsEnd();
 
  // The channel used to synchronize the state (i.e., receive measurements from
  // and push writes to) with the remote universe.
  UniverseClientChannel& channel_;
 
  // Stores all descriptors for devices handled by the remote universe. The
  // descriptors are assigned integer keys by the remote universe. These are
  // used as keys into this map.
  roo_collections::FlatSmallHashMap<int, roo_transceivers_Descriptor>
      descriptors_;
 
  // For each device known to the remote universe, points to the key of
  // the descriptor for that device. That key can be used to look up the
  // descriptor in the descriptors_ map.
  roo_collections::FlatSmallHashMap<DeviceLocator, int> device_idx_by_locator_;
 
  std::vector<DeviceEntry> devices_;
 
  std::vector<DeviceEntry> updated_devices_;
 
  bool synced_;
 
  // Cached sensor measurements.
  roo_collections::FlatSmallHashMap<SensorLocator, Measurement> readings_;
 
  // Actuators by actuator ID per device type. Allows us to quickly verify that
  // an actuator locator used for write actually does exist, before sending the
  // write request to the server.
  roo_collections::FlatSmallHashSet<ActuatorLocator> actuators_;
 
  // Event listeners for state updates.
  roo_collections::FlatSmallHashSet<EventListener*> listeners_;
 
  mutable roo::mutex state_guard_;
  mutable roo::mutex listener_guard_;
};
 
}  // namespace roo_transceivers