interface_clients.h

Go to the documentation of this file.

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#pragma once
#include "error_handling.h"
#include <adtffiltersdk/graph_object.h>
 
#include <adtfui/qt_shared_intf.h>
#include <plugins/recorder_intf.h>
#include <plugins/player_intf.h>
 
#include <QObject>
#include <QJSEngine>
 
namespace adtf
{
 
namespace javascript
{
 
namespace scripting
{
 
class cScriptRecorderClient: public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool connected READ isConnected)
 
    public:
        cScriptRecorderClient(filter::interface_client<services::ant::IRecorder> oClient, QJSEngine& oEngine):
            m_oClient(oClient),
            m_oEngine(oEngine)
        {
        }
 
        Q_INVOKABLE void start(const QString& strFileName = "")
        {
            SCRIPT_ERROR_IF_FAILED(m_oClient->Start(strFileName.toLocal8Bit().data()));
        }
 
        Q_INVOKABLE void split(const QString& strFileName = "")
        {
            SCRIPT_ERROR_IF_FAILED(m_oClient->Split(strFileName.toLocal8Bit().data()));
        }
 
        Q_INVOKABLE void stop(const QString& strFileName = "")
        {
            SCRIPT_ERROR_IF_FAILED(m_oClient->Stop(strFileName.toLocal8Bit().data()));
        }
 
        Q_INVOKABLE void addMarker(double fTimeStamp, const QString& strName = "", const QString& strAdditional = "")
        {
            SCRIPT_ERROR_IF_FAILED(ucom::ucom_cast<services::IRecorder*>(&m_oClient.Get())->AddMarker(static_cast<tTimeStamp>(fTimeStamp),
                                                                                                      strName.toStdString().c_str(),
                                                                                                      strAdditional.toStdString().c_str()));
        }
 
        Q_INVOKABLE void dropHistory()
        {
            SCRIPT_ERROR_IF_FAILED(ucom::ucom_cast<services::IRecorder*>(&m_oClient.Get())->DropHistory());
        }
 
    private:
        bool isConnected()
        {
            return m_oClient.IsValid();
        }
 
        filter::interface_client<services::ant::IRecorder> m_oClient;
        QJSEngine& m_oEngine;
 
};
 
class cScriptPlayerClient: public QObject
{
    Q_OBJECT
 
    public:
        cScriptPlayerClient(QJSEngine& oEngine):
            m_oEngine(oEngine)
        {
            THROW_IF_FAILED_DESC(_runtime->GetObject(m_pClient), "Unable to aquire player interface");
        }
 
        Q_INVOKABLE void open(const QString& strFileNames, bool bLoadReferencedFiles)
        {
            SCRIPT_ERROR_IF_FAILED(m_pClient->Open(strFileNames.toLocal8Bit().data(), bLoadReferencedFiles));
        }
 
        Q_INVOKABLE void close()
        {
            SCRIPT_ERROR_IF_FAILED(m_pClient->Close());
        }
 
        Q_INVOKABLE void play()
        {
            SCRIPT_ERROR_IF_FAILED(m_pClient->Play());
        }
 
        Q_INVOKABLE void pause()
        {
            SCRIPT_ERROR_IF_FAILED(m_pClient->Pause());
        }
 
        Q_INVOKABLE void reset()
        {
            SCRIPT_ERROR_IF_FAILED(m_pClient->Reset());
        }
 
        Q_INVOKABLE QVariantList getTimeRange()
        try
        {
            tTimeStamp tmStart;
            tTimeStamp tmEnd;
            THROW_IF_FAILED(m_pClient->GetTimeRange(tmStart, tmEnd));
            QVariantList oReturnValue;
            oReturnValue.push_back(static_cast<qint64>(base::duration_cast<base::tNanoSeconds>(tmStart).nCount));
            oReturnValue.push_back(static_cast<qint64>(base::duration_cast<base::tNanoSeconds>(tmEnd).nCount));
            return oReturnValue;
        }
        EXCEPTION_TO_SCRIPT_ERROR({})
 
        Q_INVOKABLE qint64 getCurrentTime()
        {
            return base::duration_cast<base::tNanoSeconds>(m_pClient->GetCurrentTime()).nCount;
        }
 
        Q_INVOKABLE void seekToTime(qint64 tmTime)
        {
            SCRIPT_ERROR_IF_FAILED(m_pClient->SeekToTime(base::duration_cast<tTimeStamp>(base::tNanoSeconds{tmTime})));
        }
 
    private:
        ucom::object_ptr<services::ant::IPlayer> m_pClient;
        QJSEngine& m_oEngine;
};
 
class cScriptQtSharedClient: public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool connected READ isConnected)
 
    public:
        cScriptQtSharedClient(filter::interface_client<ui::giant::IQtShared> oClient, QJSEngine& oEngine):
            m_oClient(oClient),
            m_oEngine(oEngine)
        {
        }
 
        Q_INVOKABLE QObject* getObject(const QString& strName = "")
        try
        {
            QObject* pObject;
            THROW_IF_FAILED(m_oClient->GetObject(strName.toLocal8Bit().data(), pObject));
            return pObject;
        }
        EXCEPTION_TO_SCRIPT_ERROR(nullptr)
 
    private:
        bool isConnected()
        {
            return m_oClient.IsValid();
        }
 
        filter::interface_client<ui::giant::IQtShared> m_oClient;
        QJSEngine& m_oEngine;
};
 
}
}
}