Instance.hpp

#pragma once
 
#include "audinate/dal/DAL.hpp"
#include "audinate/dal/Audio.hpp"
#include "audinate/dal/InstanceConfig.hpp"
 
#include <iostream>
 
namespace Audinate { namespace DAL {

enum class InstanceState
{
    // The DAL instance has been created but has not been started.
    Stopped,
 
    // The DAL instance is starting up
    Starting,
 
    // The DAL instance is running.
    Running,
 
    // The DAL instance is stopping
    Stopping
};

std::string toString(InstanceState state);

class InstanceEvent
{
public:
    enum class Type
    {
        // An event indicating that the instance's state has changed
        InstanceStateChanged,
        // An event indicating that the status of one of the instance's child components has changed
        ComponentStatusChanged,
        // An event indicating that the domain enrolment info of the instance has changed
        DomainInfoChanged,
        // An event indicating that the device activation status has changed
        DeviceActivationStatusChanged
    };

    Type getType() const { return mType; }

    Component getComponent() const { return mComponent; }
 
    // Set event information. For internal use only
    void set(Type type, Component component) { mType = type; mComponent = component; }
 
    // Set event information. For internal use only
    void set(Type type) { mType = type; }
 
private:
    Type mType;
    Component mComponent;
};

std::string toString(InstanceEvent::Type type);
 
//----------------------------------------------------------
// Instance Monitoring - regular rate callback providing current 
// system runtime state
//----------------------------------------------------------
 
typedef std::function<void(const InstanceEvent &)> InstanceEventFn;
 
class MonitoringEvent
{
public:
    class Timestamp
    {
    public:
        Uint32 mSeconds;
        Uint32 mNanoseconds;
 
        Timestamp(Uint32 seconds, Uint32 nanoseconds) : mSeconds(seconds), mNanoseconds(nanoseconds) {}
 
        bool operator==(const Timestamp & t) const { return mSeconds == t.mSeconds && mNanoseconds == t.mNanoseconds; }
        bool operator!=(const Timestamp & t) const { return ! operator==(t); }
    };
 
    enum class Type
    {
        MaxControlThreadInterval,
        MaxAudioThreadInterval,
        LatePacketCount, // The number of late packets seen since the last monitoring event. Only valid in PTP mode 
        NonSequentialPacketCount, // The number of packets received that were not sequential w.r.t to the previous packet received for that packet's audio flows. Usually caused by missing / dropped packets 
 
        NumTypes // must be last...
    };
 
    MonitoringEvent(Timestamp timestamp) : mTimestamp(timestamp), mTypes(), mMaxControlThreadIntervalUs(), mMaxAudioThreadIntervalUs(), mLatePacketCount(), mNonSequentialPacketCount() { mTypes.resize(static_cast<size_t>(Type::NumTypes)); }
    ~MonitoringEvent() {}
 
    Timestamp getTimestamp() const { return mTimestamp; }
 
    bool hasType(Type type) const { size_t index = static_cast<size_t>(type); return mTypes[index]; }
    void setType(Type type) { size_t index = static_cast<size_t>(type); mTypes[index] = true; }
    
 
    Uint32 getMaxControlThreadIntervalUs() const { return mMaxControlThreadIntervalUs; }
    void setMaxControlThreadIntervalUs(Uint32 interval) { setType(Type::MaxControlThreadInterval); mMaxControlThreadIntervalUs = interval; }
 
    Uint32 getMaxAudioThreadIntervalUs() const { return mMaxAudioThreadIntervalUs; }
    void setMaxAudioThreadIntervalUs(Uint32 interval) { setType(Type::MaxAudioThreadInterval); mMaxAudioThreadIntervalUs = interval; }
    
    Uint32 getLatePacketCount() const { return mLatePacketCount; }
    void setLatePacketCount(Uint32 count) {  setType(Type::LatePacketCount); mLatePacketCount = count; }
 
    Uint32 getNonSequentialPacketCount() const { return mNonSequentialPacketCount; }
    void setNonSequentialPacketCount(Uint32 count) {  setType(Type::NonSequentialPacketCount); mNonSequentialPacketCount = count; }
    
 
private:
    Timestamp mTimestamp;
    std::vector<bool> mTypes;
    Uint32 mMaxControlThreadIntervalUs;
    Uint32 mMaxAudioThreadIntervalUs;
    Uint32 mLatePacketCount;
    Uint32 mNonSequentialPacketCount;
 
};
 
typedef std::function<void(const MonitoringEvent &)> MonitoringEventFn;

class DomainInfo
{
public:
    DomainInfo() : mIsEnrolled(false), mDomainName("") {};
    bool mIsEnrolled; 
    std::string mDomainName; 
};

class Instance
{
protected:
    Instance() {}
    virtual ~Instance() {}
 
public:
 
    //------------------------------------------------------
    // Instance Management
    //------------------------------------------------------

    virtual void setEventFn(InstanceEventFn fn) = 0;

    virtual void start() = 0;

    virtual void stop() = 0;

    virtual InstanceState getInstanceState() const = 0;

    virtual SocketDescriptor getProtocolSocketDescriptor(Protocol protocol) = 0;

    virtual ComponentStatus getComponentStatus(Component component) = 0;

    virtual void clearConfiguration() = 0;

    virtual void clearDomainCredentials() = 0;

    virtual std::shared_ptr<Audio> getAudio() = 0;

    virtual void setMonitoringFn(MonitoringEventFn fn) = 0;

    virtual DomainInfo getDomainInfo() const = 0;

    virtual bool isDeviceActivated() const = 0;
};

std::shared_ptr<Instance> createInstance(std::shared_ptr<DAL> dal, const InstanceConfig & config);
 
}; };