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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * OlaClientCore.h
 * The OLA Client Core class
 * Copyright (C) 2005-2008 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 client {

class OlaClientCore: public ola::proto::OlaClientService {
 public:
    explicit OlaClientCore(ola::io::ConnectedDescriptor *descriptor);
    ~OlaClientCore();

    bool Setup();
    bool Stop();

    void SetCloseHandler(ola::SingleUseCallback0<void> *callback);

    void SetDMXCallback(RepeatableDMXCallback *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 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_