OlaClientCore.h

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * OlaClientCore.h
 * The OLA Client Core class
 * Copyright (C) 2005 Simon Newton
 */

#ifndef OLA_OLACLIENTCORE_H_
#define OLA_OLACLIENTCORE_H_

#include <memory>
#include <string>

#include "common/protocol/Ola.pb.h"
#include "common/protocol/OlaService.pb.h"
#include "common/rpc/RpcChannel.h"
#include "common/rpc/RpcController.h"
#include "ola/Callback.h"
#include "ola/DmxBuffer.h"
#include "ola/client/CallbackTypes.h"
#include "ola/client/ClientArgs.h"
#include "ola/client/ClientTypes.h"
#include "ola/base/Macro.h"
#include "ola/dmx/SourcePriorities.h"
#include "ola/io/Descriptor.h"
#include "ola/plugin_id.h"
#include "ola/rdm/UID.h"
#include "ola/rdm/UIDSet.h"
#include "ola/timecode/TimeCode.h"

namespace ola {

namespace rpc {
class RpcSession;
}

namespace client {

class OlaClientCore: public ola::proto::OlaClientService {
 public:
  typedef ola::SingleUseCallback0<void> ClosedCallback;

  explicit OlaClientCore(ola::io::ConnectedDescriptor *descriptor);
  ~OlaClientCore();

  bool Setup();
  bool Stop();

  void SetCloseHandler(ClosedCallback *callback);

  void SetDMXCallback(RepeatableDMXCallback *callback);

  void ReloadPlugins(SetCallback *callback);

  void FetchPluginList(PluginListCallback *callback);

  void FetchPluginDescription(ola_plugin_id plugin_id,
                              PluginDescriptionCallback *callback);

  void FetchPluginState(ola_plugin_id plugin_id,
                        PluginStateCallback *callback);

  void FetchDeviceInfo(ola_plugin_id plugin_filter,
                       DeviceInfoCallback *callback);

  void FetchCandidatePorts(CandidatePortsCallback *callback);

  void FetchCandidatePorts(unsigned int universe_id,
                           CandidatePortsCallback *callback);

  void ConfigureDevice(unsigned int device_alias,
                       const std::string &msg,
                       ConfigureDeviceCallback *callback);

  void SetPortPriorityInherit(unsigned int device_alias,
                              unsigned int port,
                              PortDirection port_direction,
                              SetCallback *callback);

  void SetPortPriorityOverride(unsigned int device_alias,
                               unsigned int port,
                               PortDirection port_direction,
                               uint8_t value,
                               SetCallback *callback);

  void FetchUniverseList(UniverseListCallback *callback);

  void FetchUniverseInfo(unsigned int universe,
                         UniverseInfoCallback *callback);

  void SetUniverseName(unsigned int universe,
                       const std::string &name,
                       SetCallback *callback);

  void SetUniverseMergeMode(unsigned int universe,
                            OlaUniverse::merge_mode mode,
                            SetCallback *callback);

  void Patch(unsigned int device_alias,
             unsigned int port,
             PortDirection port_direction,
             PatchAction action,
             unsigned int universe,
             SetCallback *callback);

  void RegisterUniverse(unsigned int universe,
                        RegisterAction register_action,
                        SetCallback *callback);

  void SendDMX(unsigned int universe,
               const DmxBuffer &data,
               const SendDMXArgs &args);

  void FetchDMX(unsigned int universe, DMXCallback *callback);

  void RunDiscovery(unsigned int universe,
                    DiscoveryType discovery_type,
                    DiscoveryCallback *callback);

  void SetSourceUID(const ola::rdm::UID &uid, SetCallback *callback);

  void RDMGet(unsigned int universe,
              const ola::rdm::UID &uid,
              uint16_t sub_device,
              uint16_t pid,
              const uint8_t *data,
              unsigned int data_length,
              const SendRDMArgs& args);

  void RDMSet(unsigned int universe,
              const ola::rdm::UID &uid,
              uint16_t sub_device,
              uint16_t pid,
              const uint8_t *data,
              unsigned int data_length,
              const SendRDMArgs& args);

  void SendTimeCode(const ola::timecode::TimeCode &timecode,
                    SetCallback *callback);

  void UpdateDmxData(ola::rpc::RpcController* controller,
                     const ola::proto::DmxData* request,
                     ola::proto::Ack* response,
                     CompletionCallback* done);

 private:
  ola::io::ConnectedDescriptor *m_descriptor;
  std::auto_ptr<RepeatableDMXCallback> m_dmx_callback;
  std::auto_ptr<ola::rpc::RpcChannel> m_channel;
  std::auto_ptr<ola::proto::OlaServerService_Stub> m_stub;
  int m_connected;

  void ChannelClosed(ClosedCallback *callback, ola::rpc::RpcSession *session);

  void HandlePluginList(ola::rpc::RpcController *controller_ptr,
                        ola::proto::PluginListReply *reply_ptr,
                        PluginListCallback *callback);

  void HandlePluginDescription(ola::rpc::RpcController *controller,
                               ola::proto::PluginDescriptionReply *reply,
                               PluginDescriptionCallback *callback);

  void HandlePluginState(ola::rpc::RpcController *controller,
                         ola::proto::PluginStateReply *reply,
                         PluginStateCallback *callback);

  void HandleDeviceInfo(ola::rpc::RpcController *controller,
                        ola::proto::DeviceInfoReply *reply,
                        DeviceInfoCallback *callback);

  void HandleDeviceConfig(ola::rpc::RpcController *controller,
                          ola::proto::DeviceConfigReply *reply,
                          ConfigureDeviceCallback *callback);

  void HandleAck(ola::rpc::RpcController *controller,
                 ola::proto::Ack *reply,
                 SetCallback *callback);

  void HandleGeneralAck(ola::rpc::RpcController *controller,
                        ola::proto::Ack *reply,
                        GeneralSetCallback *callback);

  void HandleUniverseList(ola::rpc::RpcController *controller,
                          ola::proto::UniverseInfoReply *reply,
                          UniverseListCallback *callback);

  void HandleUniverseInfo(ola::rpc::RpcController *controller,
                          ola::proto::UniverseInfoReply *reply,
                          UniverseInfoCallback *callback);

  void HandleGetDmx(ola::rpc::RpcController *controller,
                    ola::proto::DmxData *reply,
                    DMXCallback *callback);

  void HandleUIDList(ola::rpc::RpcController *controller_ptr,
                     ola::proto::UIDListReply *reply_ptr,
                     DiscoveryCallback *callback);

  void HandleRDM(ola::rpc::RpcController *controller,
                 ola::proto::RDMResponse *reply,
                 RDMCallback *callback);

  void GenericFetchCandidatePorts(unsigned int universe_id,
                                  bool include_universe,
                                  CandidatePortsCallback *callback);

  void SendRDMCommand(bool is_set,
                      unsigned int universe,
                      const ola::rdm::UID &uid,
                      uint16_t sub_device,
                      uint16_t pid,
                      const uint8_t *data,
                      unsigned int data_length,
                      const SendRDMArgs &args);

  ola::rdm::RDMResponse *BuildRDMResponse(
      ola::proto::RDMResponse *reply,
      ola::rdm::rdm_response_code *response_code);

  static const char NOT_CONNECTED_ERROR[];

  DISALLOW_COPY_AND_ASSIGN(OlaClientCore);
};

}  // namespace client
}  // namespace ola
#endif  // OLA_OLACLIENTCORE_H_