baseclient.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright(c) 2011 Jasem Mutlaq. All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.

 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
 Library General Public License for more details.

 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/

#pragma once

#include "indiapi.h"
#include "indibase.h"

#include <string>
#include <vector>

#include <thread>

#ifdef _WINDOWS
#include <WinSock2.h>
#endif

#define MAXRBUF 2048

class INDI::BaseClient : public INDI::BaseMediator
{
  public:
    BaseClient();
    virtual ~BaseClient();

    void setServer(const char *hostname, unsigned int port);

    void watchDevice(const char *deviceName);

    bool connectServer();

    bool disconnectServer();

    void connectDevice(const char *deviceName);

    void disconnectDevice(const char *deviceName);

    INDI::BaseDevice *getDevice(const char *deviceName);

    const std::vector<INDI::BaseDevice *> &getDevices() const { return cDevices; }

    bool getDevices(std::vector<INDI::BaseDevice *> &deviceList, uint16_t driverInterface);

    void setBLOBMode(BLOBHandling blobH, const char *dev, const char *prop = NULL);

    BLOBHandling getBLOBMode(const char *dev, const char *prop = NULL);

    // Update
    static void *listenHelper(void *context);

    const char *getHost() { return cServer.c_str(); }
    int getPort() { return cPort; }

    void sendNewText(ITextVectorProperty *pp);
    void sendNewText(const char *deviceName, const char *propertyName, const char *elementName, const char *text);
    void sendNewNumber(INumberVectorProperty *pp);
    void sendNewNumber(const char *deviceName, const char *propertyName, const char *elementName, double value);
    void sendNewSwitch(ISwitchVectorProperty *pp);
    void sendNewSwitch(const char *deviceName, const char *propertyName, const char *elementName);

    void startBlob(const char *devName, const char *propName, const char *timestamp);
    void sendOneBlob(IBLOB *bp);
    void sendOneBlob(const char *blobName, unsigned int blobSize, const char *blobFormat, void *blobBuffer);
    void finishBlob();

    void setVerbose(bool enable) { verbose = enable; }

    bool isVerbose() const { return verbose; }

    void setConnectionTimeout(uint32_t seconds, uint32_t microseconds)
    {
        timeout_sec = seconds;
        timeout_us  = microseconds;
    }

  protected:
    int dispatchCommand(XMLEle *root, char *errmsg);

    int deleteDevice(const char *devName, char *errmsg);

    int delPropertyCmd(XMLEle *root, char *errmsg);

    INDI::BaseDevice *findDev(const char *devName, char *errmsg);
    INDI::BaseDevice *addDevice(XMLEle *dep, char *errmsg);
    INDI::BaseDevice *findDev(XMLEle *root, int create, char *errmsg);

    int messageCmd(XMLEle *root, char *errmsg);

    virtual void newUniversalMessage(std::string message);

  private:
    typedef struct
    {
        std::string device;
        std::string property;
        BLOBHandling blobMode;
    } BLOBMode;

    BLOBMode *findBLOBMode(const std::string& device, const std::string& property);

    void setDriverConnection(bool status, const char *deviceName);

    void clear();

    std::thread *listen_thread=nullptr;

#ifdef _WINDOWS
    SOCKET sockfd;
#else
    int sockfd;
    int m_receiveFd;
    int m_sendFd;
#endif

    // Listen to INDI server and process incoming messages
    void listenINDI();

    void sendString(const char *fmt, ...);

    std::vector<INDI::BaseDevice *> cDevices;
    std::vector<std::string> cDeviceNames;
    std::vector<BLOBMode *> blobModes;

    std::string cServer;
    unsigned int cPort;
    bool sConnected;
    bool verbose;

    // Parse & FILE buffers for IO

    LilXML *lillp; /* XML parser context */
    uint32_t timeout_sec, timeout_us;
};