group__AudioApiCPP.html

#include <iostream>
#include <dpy/audioApi.h>
#include <boost/thread.hpp>
volatile bool waiting = true;
using namespace dpyAudio;
static Audio audio;
static std::map<dpyAudio::PortType, std::string> portTypeToStringMap;
static std::list<dpyAudio::Port> gUserPortsList;
static std::list<dpyAudio::Connection> gConnectionsList;
static dpyAudio::Port userOutPort, userInPort;
static dpyAudio::Port systemOutPort, systemInPort;
void set_connection_volume_handler(boost::system::error_code &ec, dpyAudio::Connection connection, unsigned int volume);
void set_connection_gain_handler(boost::system::error_code &ec, dpyAudio::Connection connection, unsigned int gain);
void printConnectionList(boost::system::error_code &ec, std::list<dpyAudio::Connection> connectionList);
void port_list_handler(boost::system::error_code &ec, std::list<dpyAudio::Port> portList);
void create_port_handler(boost::system::error_code& ec, dpyAudio::Port& port);
void remove_port_handler(boost::system::error_code &ec, dpyAudio::Port &port);
void create_connection_handler(boost::system::error_code &ec, dpyAudio::Connection connection);
void remove_connection_handler(boost::system::error_code &ec, dpyAudio::Connection connection);
void set_connection_volume_handler(boost::system::error_code &ec, dpyAudio::Connection connection, unsigned int volume)
{
    if (ec.value() == 0) {
        std::cout << "\rConnection [" << connection.id << "] volume updated correctly to " << volume << ". " << std::endl;
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void set_connection_gain_handler(boost::system::error_code &ec, dpyAudio::Connection connection, unsigned int gain)
{
    if (ec.value() == 0) {
        std::cout << "\rConnection [" << connection.id << "] gain updated correctly to " << gain << ". " << std::endl;
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void printConnectionList(boost::system::error_code &ec, std::list<dpyAudio::Connection> connectionList)
{
    if (ec.value() == 0) {
        gConnectionsList.clear();
        std::cout << "\rConnection list: " << std::endl;
        std::cout << "\tConnection id\t|\t     Origin Port    \t|\t     Destination Port    \t|\tPriority\t|\tState\t|\tVolume\t|\tGain\t|\tBlocked By\n";
        std::cout << "\t---------------------------------------------------------------------------------------------------------------------------------\n";
        // Iterate and print values of the list
        for (auto const &c : connectionList) {
            gConnectionsList.push_back(c);
            std::cout << "\t" << c.id;
            std::string originPort = c.originPort.client + ":" + c.originPort.name;
            std::string destinationPort = c.destinationPort.client + ":" + c.destinationPort.name;
            std::cout << "\t|\t" << originPort << "\t|\t";
            std::cout << destinationPort << "\t|\t";
            std::cout << c.priority << "\t|\t";
            if (c.isActive) {
                std::cout << "ENABLED";
            } else {
                std::cout << "DISABLED";
            }
            std::cout << "\t|\t";
            std::cout << c.volume << "\t|\t";
            std::cout << c.gain << "\t|\t";
            for (auto block : c.blockedBy) {
                std::cout << block << " ";
            }
            std::cout << std::endl;
        }
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void port_list_handler(boost::system::error_code &ec, std::list<dpyAudio::Port> portList)
{
    if (ec.value() == 0) {
        //Create connection
        if (portList.size() != 0) {
            for (auto const& p : portList) {
                if (p.type == PortType::INPUT && p.client.find("user") == std::string::npos) {
                    systemInPort = p; //Take the first of the speakers
                    break;
                }
            }
            for (auto const& p : portList) {
                if (p.type == PortType::OUTPUT && p.client.find("user") == std::string::npos) {
                    systemOutPort = p; //Take the first of the microphones
                    break;
                }
            }
        } else {
            std::cout << "Port list is not available or cannot be read" << std::endl;
        }
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void create_port_handler(boost::system::error_code& ec, dpyAudio::Port& port)
{
    if (ec.value() == 0) {
        std::cout << "\rPort with name  [" << port.name << "] created correctly. Type " << portTypeToStringMap[port.type] << ". Port full name [" << port.client << ":" << port.name << "]" << std::endl;
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void remove_port_handler(boost::system::error_code &ec, dpyAudio::Port &port)
{
    if (ec.value() == 0) {
        std::cout << "\rPort with name  [" << port.getPortFullName() << "] removed correctly." << std::endl;
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void create_connection_handler(boost::system::error_code &ec, dpyAudio::Connection connection)
{
    if (ec.value() == 0) {
        std::cout << "Connection [" << connection.id << "] created correctly :  Origin " << connection.originPort.getPortFullName() << "  --> Destination " << connection.destinationPort.getPortFullName() << std::endl;
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
void remove_connection_handler(boost::system::error_code &ec, dpyAudio::Connection connection)
{
    if (ec.value() == 0) {
        std::cout << "\rConnection [" << connection.id << "] removed correctly. " << std::endl;
    } else {
        std::cout << "\rError : " << ec.message() << std::endl;
    }
    waiting = false;
}
int main() {
    waiting = true;
    portTypeToStringMap[dpyAudio::PortType::NA_TYPE] = "Not available ";
    portTypeToStringMap[dpyAudio::PortType::INPUT] = "Input";
    portTypeToStringMap[dpyAudio::PortType::OUTPUT] = "Output";
    userOutPort.client = "user1";
    userOutPort.name = "output_1";
    userOutPort.type = PortType::OUTPUT;
    std::cout << "Creating user port" << std::endl;
    audio.asyncCreatePort(userOutPort, create_port_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    gUserPortsList.push_back(userOutPort);
    userInPort.client = "user2";
    userInPort.name = "input_1";
    userInPort.type = PortType::INPUT;
    std::cout << "Creating user port" << std::endl;
    audio.asyncCreatePort(userInPort, create_port_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    gUserPortsList.push_back(userInPort);
    audio.asyncGetPortList(port_list_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    Connection connectionBlocked;
    connectionBlocked.id = "connectionBlocked";
    connectionBlocked.originPort = userOutPort;
    connectionBlocked.destinationPort = systemInPort;
    connectionBlocked.priority = 20;
    connectionBlocked.volume = 50;
    std::cout << "Creating connection [" << connectionBlocked.id << "].\nConnecting port " << connectionBlocked.originPort.getPortFullName() << " with port " << connectionBlocked.destinationPort.getPortFullName() << std::endl;
    audio.asyncCreateConnection(connectionBlocked, create_connection_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    Connection connection1;
    connection1.id = "connection1";
    connection1.originPort = userOutPort;
    connection1.destinationPort = systemInPort;
    connection1.priority = 10;
    connection1.volume = 70;
    std::cout << "Creating connection [" << connection1.id << "].\nConnecting port " << connection1.originPort.getPortFullName() << " with port " << connection1.destinationPort.getPortFullName() << std::endl;
    audio.asyncCreateConnection(connection1, create_connection_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    Connection connection2;
    connection2.id = "connection2";
    connection2.originPort = systemOutPort;
    connection2.destinationPort = userInPort;
    connection2.priority = 5;
    connection2.gain = 60;
    std::cout << "Creating connection [" << connection2.id << "].\nConnecting port " << connection2.originPort.getPortFullName() << " with port " << connection2.destinationPort.getPortFullName() << std::endl;
    audio.asyncCreateConnection(connection2, create_connection_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    audio.asyncGetConnectionList(printConnectionList);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    int newVolume = 55;
    std::cout << "Changing volume of [" << connection1.id << "] to " << newVolume;
    audio.asyncSetVolume(connection1, newVolume, set_connection_volume_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    int newGain = 42;
    std::cout << "Changing gain of [" << connection2.id << "] to " << newGain;
    audio.asyncSetGain(connection2, newGain, set_connection_gain_handler);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    audio.asyncGetConnectionList(printConnectionList);
    while (waiting == true)
    {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
    }
    waiting = true;
    std::cout << "Removing connections." << std::endl;
    for (auto const &c : gConnectionsList) {
        audio.asyncRemoveConnection(c, remove_connection_handler);
        while (waiting == true)
        {
            boost::this_thread::sleep_for(boost::chrono::seconds(1));
        }
        waiting = true;
    }
    std::cout << "Removing ports." << std::endl;
    for (auto const &port : gUserPortsList) {
        audio.asyncRemovePort(port, remove_port_handler);
        while (waiting == true)
        {
            boost::this_thread::sleep_for(boost::chrono::seconds(1));
        }
        waiting = true;
    }
    return 0;
}
Namespaces
	dpyAudio
	Deepsy Audio namespace that includes the different enums, structs or method signatures that should be used.
Classes
class	ServiceAvailabilityObserver
	Service Availability observer class. More...

class	Audio
	Allows to interact with a Audio service. More...

class	AudioTaskObserver
	Audio Task Observer class. More...

class	IAudioTask
	Interface representing a Audio Task which will be reproduced in a specific port. More...