al_ParameterServer.hpp

#ifndef AL_PARAMETERSERVER_H
#define AL_PARAMETERSERVER_H
 
/*  Allolib --
        Multimedia / virtual environment application class library
 
        Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology,
   UCSB. Copyright (C) 2012-2018. The Regents of the University of California.
        All rights reserved.
 
        Redistribution and use in source and binary forms, with or without
        modification, are permitted provided that the following conditions are
   met:
 
                Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 
                Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following disclaimer in the
                documentation and/or other materials provided with the
   distribution.
 
                Neither the name of the University of California nor the names
   of its contributors may be used to endorse or promote products derived from
                this software without specific prior written permission.
 
        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
        File description:
    Expose parameters on the network
        File author(s):
        Andrés Cabrera mantaraya36@gmail.com
*/
 
#include <mutex>
 
#include "al/protocol/al_OSC.hpp"
#include "al/ui/al_Parameter.hpp"
#include "al/ui/al_ParameterBundle.hpp"
 
namespace al {
 
constexpr int handshakeServerPort = 16987;
constexpr int listenerFirstPort = 14000;
 
class ParameterServer;
 
class OSCNode {
public:
  OSCNode() {
    mCommandHandler.node = this;
 
    mNetworkListener.appendHandler(mCommandHandler);
  }
 
  void startCommandListener(std::string address = "0.0.0.0");
 
  virtual void runCommand(osc::Message &m) = 0;
 
  void registerServerHandler(osc::PacketHandler *handler);
 
private:
  class CommandHandler : public osc::PacketHandler {
  public:
    OSCNode *node;
    virtual void onMessage(osc::Message &m) override {
      std::cout << "command handler got" << std::endl;
      m.print();
      node->runCommand(m);
    }
  } mCommandHandler;
  osc::Recv mNetworkListener;
};
 
class OSCNotifier {
public:
  OSCNotifier();
  virtual ~OSCNotifier();
 
  virtual void addListener(std::string IPaddress, uint16_t oscPort) {
    auto newListenerSocket = new osc::Send;
 
    if (newListenerSocket->open(oscPort, IPaddress.c_str())) {
      mListenerLock.lock();
      mOSCSenders.push_back(newListenerSocket);
      mListenerLock.unlock();
      //        std::cout << "Registered listener " << IPaddress << ":"
      //<< oscPort<< std::endl;
    } else {
      delete newListenerSocket;
      std::cerr << "ERROR: Could not register listener " << IPaddress << ":"
                << oscPort << std::endl;
    }
  }
 
  void notifyListeners(std::string OSCaddress, float value,
                       ValueSource *src = nullptr);
  void notifyListeners(std::string OSCaddress, int value,
                       ValueSource *src = nullptr);
  void notifyListeners(std::string OSCaddress, std::string value,
                       ValueSource *src = nullptr);
  void notifyListeners(std::string OSCaddress, Vec3f value,
                       ValueSource *src = nullptr);
  void notifyListeners(std::string OSCaddress, Vec4f value,
                       ValueSource *src = nullptr);
  void notifyListeners(std::string OSCaddress, Pose value,
                       ValueSource *src = nullptr);
  void notifyListeners(std::string OSCaddress, Color value,
                       ValueSource *src = nullptr);
 
  void notifyListeners(std::string OSCaddress, ParameterMeta *param,
                       ValueSource *src);
 
  void send(osc::Packet &p) {
    mListenerLock.lock();
    for (osc::Send *sender : mOSCSenders) {
      sender->send(p);
      //      std::cout << "Notifying " << sender->address() << ":" <<
      //      sender->port()
      //                << std::endl;
    }
    mListenerLock.unlock();
  }
  void startHandshakeServer(std::string address = "0.0.0.0");
 
  void appendCommandHandler(osc::PacketHandler &handler) {
    mHandshakeServer.appendHandler(handler);
  }
 
protected:
  std::mutex mListenerLock;
  std::vector<osc::Send *> mOSCSenders;
  std::vector<std::pair<std::string, int>> mConnectedNodes;
 
  class HandshakeHandler : public osc::PacketHandler {
  public:
    OSCNotifier *notifier;
    ParameterServer *mParameterServer;
    virtual void onMessage(osc::Message &m) override;
  } mHandshakeHandler;
 
  osc::Recv mHandshakeServer;
 
  std::vector<std::pair<std::string, uint16_t>> mNodes;
  std::mutex mNodeLock;
 
private:
};
 
class ParameterServer : public osc::PacketHandler,
                        public OSCNotifier,
                        public OSCNode {
  friend class PresetServer; // To be able to take over the OSC server
public:
  // ParameterServer() : mServer(nullptr) {};
  ParameterServer(std::string oscAddress = "", int oscPort = 9010,
                  bool autoStart = true);
  ~ParameterServer();
 
  void configure(uint16_t port, std::string addr = "") {
    mOscPort = port;
    mOscAddress = addr;
  }
  bool listen(int oscPort = -1, std::string oscAddress = "");
 
  ParameterServer &registerParameter(ParameterMeta &param);
 
  void unregisterParameter(ParameterMeta &param);
 
  ParameterServer &registerParameterBundle(ParameterBundle &bundle);
 
  void print(std::ostream &stream = std::cout);
 
  void stopServer();
 
  bool serverRunning();
 
  std::vector<Parameter *> parameters();
  std::vector<ParameterString *> stringParameters();
  std::vector<ParameterVec3 *> vec3Parameters();
  std::vector<ParameterVec4 *> vec4Parameters();
  std::vector<ParameterPose *> poseParameters();
 
  template <class ParameterType>
  ParameterServer &operator<<(ParameterType &newParam) {
    return registerParameter(newParam);
  }
 
  template <class ParameterType>
  ParameterServer &operator<<(ParameterType *newParam) {
    return registerParameter(*newParam);
  }
 
  ParameterServer &operator<<(ParameterBundle &bundle) {
    return registerParameterBundle(bundle);
  }
 
  void registerOSCListener(osc::PacketHandler *handler);
 
  void clearOSCListeners() { mPacketHandlers.clear(); }
 
  void registerOSCConsumer(osc::MessageConsumer *consumer,
                           std::string rootPath = "");
 
  void notifyAll();
 
  void sendAllParameters(std::string IPaddress, int oscPort);
 
  void sendParameterDetails(std::string IPaddress, int oscPort);
 
  void requestAllParameters(std::string IPaddress, int oscPort);
 
  virtual void onMessage(osc::Message &m) override;
 
  uint16_t serverPort() { return mServer->port(); }
 
  void verbose(bool verbose = true) { mVerbose = verbose; }
  static bool setParameterValueFromMessage(ParameterMeta *param,
                                           std::string address,
                                           osc::Message &m);
 
  virtual void runCommand(osc::Message &m) override;
 
protected:
  static void changeCallback(float value, void *sender, void *userData,
                             void *blockThis);
  static void changeStringCallback(std::string value, void *sender,
                                   void *userData, void *blockThis);
  static void changeVec3Callback(Vec3f value, void *sender, void *userData,
                                 void *blockThis);
  static void changeVec4Callback(Vec4f value, void *sender, void *userData,
                                 void *blockThis);
  static void changePoseCallback(Pose value, void *sender, void *userData,
                                 void *blockThis);
 
  void printParameterInfo(ParameterMeta *p);
 
  void printBundleInfo(ParameterBundle *bundle, std::string id, int depth = 0);
 
  void setValuesForBundleGroup(osc::Message &m,
                               std::vector<ParameterBundle *> bundleGroup,
                               std::string rootAddress);
 
  std::vector<std::pair<std::string, uint16_t>>
      mNotifiers; // List of primary nodes
 
  std::vector<osc::PacketHandler *> mPacketHandlers;
  std::vector<std::pair<osc::MessageConsumer *, std::string>> mMessageConsumers;
  osc::Recv *mServer;
  std::mutex mServerLock;
 
  std::vector<ParameterMeta *> mParameters;
  std::map<std::string, std::vector<ParameterBundle *>> mParameterBundles;
  std::map<std::string, int> mCurrentActiveBundle;
  std::mutex mParameterLock;
 
  std::string mOscAddress;
  int mOscPort;
 
  bool mVerbose{false};
};
 
} // namespace al
 
#endif // AL_PARAMETERSERVER_H