Connections.hpp

#pragma once
 
#include "audinate/dal/Common.hpp"
#include "audinate/dal/ConnectionsConfig.hpp"
#include "audinate/dal/DAL.hpp"
 
#include <vector>
#include <functional>
 
 
namespace Audinate { namespace DAL {
 
//------------------------------------------------------
// Connection API
//------------------------------------------------------

class LocalDevice
{
public:
    LocalDevice() : mNumTxChannels(), mNumRxChannels() {}
 
    bool operator==(const LocalDevice & other) const { return mNumTxChannels == other.mNumTxChannels && mNumRxChannels == other.mNumRxChannels; }
    bool operator!=(const LocalDevice & other) const { return !(operator==(other)); }
 
    unsigned int mNumTxChannels;
    unsigned int mNumRxChannels;
};

class DeviceChannels
{
public:
    DeviceChannels() : mDeviceName(), mChannelNames(), mIpv4Address(), mIdentifiable(), mSending() {}
    bool operator==(const DeviceChannels & other) const { return mDeviceName == other.mDeviceName && mChannelNames == other.mChannelNames && mIpv4Address == other.mIpv4Address && mIdentifiable == other.mIdentifiable && mSending == other.mSending; }
    bool operator!=(const DeviceChannels & other) const { return !(operator==(other)); }
 
    std::string mDeviceName;
    std::vector<std::string> mChannelNames;
    Ipv4Address mIpv4Address;
    bool mIdentifiable;
 
    // Is the device sending any audio at the moment?
    bool mSending;
};

class AvailableChannels
{
public:
    AvailableChannels() : mDevices() {}
    bool operator==(const AvailableChannels & other) const { return mDevices == other.mDevices; }
    bool operator!=(const AvailableChannels & other) const { return !(operator==(other)); }
 
    std::vector<DeviceChannels> mDevices;
};
 
enum class ConnectionStatus
{
    // There is no connection set for the given local channel.
    None,   
 
    // The connection API has not yet begun processing the connection
    Pending,
 
    // The requested source device was not found. Only applicable for receive channels
    Unresolved,
 
    // The requested destination device was not found. Only applicable for transmit channels
    DestinationDeviceNotFound,
 
    // The requested destination channel was not found on the destination device. Only applicable for transmit channels
    DestinationChannelNotFound,
 
    // The connection is being made. See the subscription status for more detailed information
    InProgress,
 
    // The connection has been made but no audio packets have been received
    Inactive,
 
    // The connection has been made and audio packets are being received
    Active,
 
    // The connection failed for some reason. See the subscription status for more detailed information
    Error
};
 
std::string toString(ConnectionStatus status);
 
typedef Uint8 SubscriptionStatus;
 
std::string subscriptionStatusToString(uint8_t subscriptionStatus);

class Connection
{
public:
    unsigned int mLocalChannelId; 
    std::string mRemoteChannelName; 
    std::string mRemoteDeviceName; 
 
    ConnectionStatus mConnectionStatus; 
    SubscriptionStatus mSubscriptionStatus; 
};

typedef std::function<void()> LocalDeviceChangedFn;

typedef std::function<void(std::vector<unsigned int> txChannelIds, std::vector<unsigned int> rxChannelIds)> AvailableChannelsChangedFn;

typedef std::function<void(ChannelDirection dir, std::vector<unsigned int> channelIds)> ConnectionChangedFn;
 
class Connections
{
protected:
    Connections() {}
    
public:
    virtual ~Connections() {}

    virtual LocalDevice getLocalDevice() = 0;

    virtual AvailableChannels getAvailableSources(unsigned int rxChannelId) = 0;

    virtual AvailableChannels getAvailableDestinations(unsigned int txChannelId) = 0;

    virtual void identify(const std::string & deviceName) = 0;

    virtual void setReceiveChannelSource(unsigned int rxChannelId, const std::string & remoteChannelName, const std::string & remoteDeviceName) = 0;

    virtual Connection getReceiveChannelState(unsigned int rxChannelId) = 0;

    virtual void setTransmitChannelDestination(unsigned int txChannelId, const std::string & remoteChannelName, const std::string & remoteDeviceName) = 0;

    virtual Connection getTransmitChannelState(unsigned int txChannelId) = 0;

    virtual void clearRemoteSubscriptionsToLocalDevice() = 0;

    virtual void setLocalDeviceChangedFn(LocalDeviceChangedFn fn) = 0;

    virtual void setAvailableChannelsChangedFn(AvailableChannelsChangedFn fn) = 0;

    virtual void setConnectionChangedFn(ConnectionChangedFn fn) = 0;
 
};

std::shared_ptr<Connections> createConnections(std::shared_ptr<DAL> dal, const ConnectionsConfig & config);
 
}; };