adtf_remote_session_intf.h

Go to the documentation of this file.

#pragma once
#include <adtf_utils.h>
#include <adtfucom3/adtf_ucom3.h>
#include <adtfstreaming3/adtf_streaming3.h>
 
namespace adtf
{
namespace remote
{
namespace ant
{

class ISession 
{
    public:
        ADTF_IID(ISession, "session.ant.remote.adtf");
        static constexpr const tChar* const DEFAULT_NAME = "session";
 
    public:
        /*
         * @return The URL of the currently loaded session file.
         */
        virtual const char* GetSessionUrl() const = 0;
 
        /*
         * @return The URL of the currently loaded system file.
         */
        virtual const char* GetSystemUrl() const = 0;
 
        /*
         * @return The URL of the currently loaded system properties file.
         */
        virtual const char* GetSystemPropertiesUrl() const = 0;
 
        /*
         * @return The URL of the currently loaded graph file.
         */
        virtual const char* GetGraphUrl() const = 0;
 
        /*
         * @return The URL of the currently loaded graph properties file.
         */
        virtual const char* GetGraphPropertiesUrl() const = 0;
 
        /*
         * @return The name of the currently loaded session.
         */
        virtual const char* GetSessionName() const = 0;

        virtual tResult LoadGraphFromUrl(const char* strGraphFile) = 0;

        virtual tResult LoadGraphPropertiesFromUrl(const char* strPropertiesFile) = 0;
 
        /*
         * @return The name of the active filter graph.
         */
        virtual const char* GetActiveFilterGraph() const = 0;

        virtual tResult SetActiveFilterGraph(const char* strFilterGraphName) = 0;
 
        /*
         * @return The name of the active streaming graph.
         */
        virtual const char* GetActiveStreamingGraph() const = 0;

        virtual tResult SetActiveStreamingGraph(const char* strStreamingGraphName) = 0;
};
}
 
namespace catwo
{
 
class ISession: public ant::ISession
{
    public:
        ADTF_IID(ISession, "session.catwo.remote.adtf");
 
    public:
        virtual const char* GetObjects() const = 0;

        virtual const char* GetProperties(const char* strObject) const = 0;

        virtual const char* GetProperty(const char* strObject,
                                        const char* strPropertyName) const = 0;

        virtual tResult SetProperty(const char* strObject,
                                    const char* strPropertyName,
                                    const char* strPropertyValue) = 0;
};
 
}
 
namespace hollow
{
 
class ISession: public catwo::ISession
{
    public:
        ADTF_IID(ISession, "session.hollow.remote.adtf");
 
    public:
        enum tPropertyFlags
        {
            None = 0x00,
        };
 
    public:

        virtual const char* GetObjectProperties(const char* strObject, uint32_t nFlags = tPropertyFlags::None) const = 0;

        virtual const char* GetPropertyType(const char* strObject,
                                            const char* strPropertyName) const = 0;
 
 
};
 
}
 
namespace quiet
{
 
class ISession : public hollow::ISession
{
    public:
        ADTF_IID(ISession, "session.quiet.remote.adtf");

        virtual const char* GetGraphObjects() const = 0;
 
        enum class tGraphObjectConnectableType : uint8_t
        {
            in = 0,
            out = 1
        };

        struct tGraphConnectableObjectInfo
        {
            std::string strName = {};
            tGraphObjectConnectableType eInOut = {};
            adtf::ucom::object_ptr<const adtf::streaming::ant::IStreamType> pStreamType = {};
            std::vector<std::string> vecConnectedGraphObjects = {};
        };
        
        enum class tGraphObjectInfoType : uint8_t
        {
            unknown = 0,
            filter,
            samplestreamingsource,
            samplestreamingsink,
            inpin,
            outpin,
            samplestream,
            subgraph,
            inport,
            outport,
            activerunner
        };

        struct tGraphObjectInfo
        {
            tGraphObjectInfoType eObjectType = {};
            std::vector<tGraphConnectableObjectInfo> vecConnectableObjects = {};
        };

        virtual tGraphObjectInfo GetGraphObjectInfo(const char* strObject) const = 0;

        virtual std::unordered_map<std::string, tGraphObjectInfo> GetGraphObjectsInfo() const = 0;
};
 
} // namespace quiet
 
namespace ultron
{
 
class ISession : public quiet::ISession
{
public:
    ADTF_IID(ISession, "session.ultron.remote.adtf");
 
    enum class tGraphObjectStateValue : uint8_t
    {
        Other = 0,
        Stopped = 1,
        Started = 2
    };
    struct tGraphObjectState
    {
        tGraphObjectInfoType eObjectType = {};

        tGraphObjectStateValue eState = {};
    };

    virtual tGraphObjectState GetGraphObjectState(const char* strObjectName) const = 0;

    virtual tResult SetGraphObjectState(const char* strObjectName, tGraphObjectStateValue eState) = 0;
};
} // namespace thor
 
using ultron::ISession;
 
}
}