baseclientqt.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright(c) 2016 Jasem Mutlaq. All rights reserved.
 
 INDI Qt Client
 
 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 "indidevapi.h"
#include "indibase.h"
 
#include <QTcpSocket>
 
#include <vector>
#include <string>
#include <map>
#include <set>
 
#if defined(_MSC_VER)
#include <BaseTsd.h>
typedef SSIZE_T ssize_t;
#endif
 
// #define MAXRBUF 2048 // #PS: defined in indibase.h
 
class INDI::BaseClientQt : public QObject, public INDI::BaseMediator
{
        Q_OBJECT
 
    public:
        BaseClientQt(QObject *parent = Q_NULLPTR);
        virtual ~BaseClientQt();
 
        void setServer(const char *hostname, unsigned int port);
 
        void watchDevice(const char *deviceName);
 
        void watchProperty(const char *deviceName, const char *propertyName);
 
        bool connectServer();
 
        bool disconnectServer();
 
        bool isServerConnected() const;
 
        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 = nullptr);
 
        BLOBHandling getBLOBMode(const char *dev, const char *prop = nullptr);
 
        // 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();
 
        QTcpSocket client_socket;
 
        std::vector<INDI::BaseDevice *> cDevices;
        std::vector<std::string> cDeviceNames;
        std::vector<BLOBMode *> blobModes;
        std::map<std::string, std::set<std::string>> cWatchProperties;
 
        std::string cServer;
        uint32_t cPort;
        bool sConnected;
        bool verbose;
 
        // Parse & FILE buffers for IO
 
        LilXML *lillp; /* XML parser context */
        uint32_t timeout_sec, timeout_us;
 
    private slots:
 
        void listenINDI();
        void processSocketError(QAbstractSocket::SocketError socketError);
};