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 SetPluginState(ola_plugin_id plugin_id,
 bool state,
 SetCallback *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::RDMStatusCode *status_code);

 static const char NOT_CONNECTED_ERROR[];

 DISALLOW_COPY_AND_ASSIGN(OlaClientCore);
};

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