poll merge squash
This commit is contained in:
parent
308a0486b6
commit
40bee90610
21 changed files with 2753 additions and 261 deletions
|
|
@ -1,50 +1,337 @@
|
|||
#include "backlasses.h"
|
||||
#include "contclasses.h"
|
||||
//TODO: pragma once
|
||||
|
||||
Overseer OverseerHandler::os;
|
||||
|
||||
EndpointHandler::EndpointHandler(Endpoint *ept, QObject *parent) : QObject(parent) {
|
||||
this->ept = ept;
|
||||
eptName = QString::fromStdWString(ept->getName());
|
||||
EndpointHandler::EndpointHandler(uint64_t idx, Flows flow) {
|
||||
//std::vector<Endpoint*> endpoints = osh->getPlaybackEndpoints().at(idx);
|
||||
this->idx = idx;
|
||||
this->flow = flow;
|
||||
this->ep = (flow == Flows::FLOW_PLAYBACK ? osh->getPlaybackEndpoints().at(idx) : osh->getCaptureEndpoints().at(idx));
|
||||
|
||||
epc = new EndpointVolumeCallback(ep);
|
||||
ensc = new EndpointNewSessionCallback(this);
|
||||
this->callbackInfo.caller = osh->getGuid();
|
||||
ep->registerNewSessionNotification(ensc);
|
||||
//epName = ep->getName();
|
||||
this->setBackEndpointVolumeCallbackInfoContent(this->getState());
|
||||
osh->pushBackEndpointHandler(this, flow);
|
||||
|
||||
if (this->flow == Flows::FLOW_PLAYBACK) {
|
||||
for (int i = 0; i < this->getSessionCount(); i++) {
|
||||
SessionHandler* sessionHandler = new SessionHandler(this, this->getSessions().at(i),i);
|
||||
sessionHandlers.push_back(sessionHandler);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void OverseerHandler::pushBackEndpointHandler(EndpointHandler* eph, Flows flow) {
|
||||
if (eph == nullptr) return;
|
||||
if (flow == Flows::FLOW_PLAYBACK)
|
||||
this->playbackEndpointHandlers.push_back(eph);
|
||||
else
|
||||
this->captureEndpointHandlers.push_back(eph);
|
||||
return;
|
||||
}
|
||||
|
||||
void EndpointHandler::setFrontVisibilityInfo(EndpointState state, uint64_t frontIdx){
|
||||
ephfv.visibility = state;
|
||||
ephfv.frontIdx = frontIdx;
|
||||
}
|
||||
|
||||
uint64_t EndpointHandler::getFrontVisibilityIndex(){
|
||||
return ephfv.frontIdx;
|
||||
}
|
||||
|
||||
EndpointState EndpointHandler::getFrontVisibilityState(){
|
||||
return ephfv.visibility;
|
||||
}
|
||||
|
||||
Flows EndpointHandler::getFlow(){
|
||||
return ep->getFlow();
|
||||
}
|
||||
|
||||
/* these two, currently unused. If I use them, I should feel bad.
|
||||
* Endpoint* EndpointHandler::getEndpoint() {
|
||||
* return this->ep;
|
||||
* }
|
||||
*
|
||||
* EndpointVolumeCallback* EndpointHandler::getEndpointVolumeCallback() {
|
||||
* return this->epc;
|
||||
* }
|
||||
*/
|
||||
|
||||
BackEndpointVolumeCallbackInfo* EndpointHandler::getCallbackInfo(){
|
||||
return &this->callbackInfo;
|
||||
}
|
||||
|
||||
uint32_t EndpointHandler::getChannelCount(){
|
||||
return ep->getChannelCount();
|
||||
}
|
||||
|
||||
void EndpointHandler::setIndex(uint64_t idx){
|
||||
this->idx = idx;
|
||||
}
|
||||
|
||||
uint64_t EndpointHandler::getIndex(){
|
||||
return idx;
|
||||
}
|
||||
|
||||
/*
|
||||
* -1 for master volume
|
||||
*/
|
||||
void EndpointHandler::setValue(int channel, int value){
|
||||
if (channel == ENDPOINT_MASTER_VOLUME)
|
||||
ept->setVolume(channel, (float)value / 100);
|
||||
else ept->setVolume(channel, (float)value / 100);
|
||||
void EndpointHandler::setVolume(NGuid guid, int channel, int value){
|
||||
if (channel == AudioChannel::CHANNEL_MAIN)
|
||||
ep->setVolume(guid, channel, (float)value / 100);
|
||||
else ep->setVolume(guid, channel, (float)value / 100);
|
||||
}
|
||||
|
||||
void EndpointHandler::setMute(){
|
||||
//Qt momento, de ahi el param?
|
||||
log_debugcpp("kinda handling the muting tbh");
|
||||
ept->setMute();
|
||||
void EndpointHandler::setMute(NGuid guid, bool muted){
|
||||
ep->setMute(guid, muted);
|
||||
}
|
||||
|
||||
QString EndpointHandler::getName(){
|
||||
return eptName;
|
||||
std::wstring EndpointHandler::getName(){
|
||||
return ep->getName();
|
||||
}
|
||||
|
||||
std::wstring EndpointHandler::getId(){
|
||||
return ep->getId();
|
||||
}
|
||||
|
||||
float EndpointHandler::getVolume(int channel){
|
||||
return ept->getVolume(channel);
|
||||
return ep->getVolume(channel);
|
||||
}
|
||||
|
||||
bool EndpointHandler::getMute(){
|
||||
return ept->getMute();
|
||||
return ep->getMute();
|
||||
}
|
||||
|
||||
Overseer* OverseerHandler::getOverseer(){
|
||||
return &os;
|
||||
size_t EndpointHandler::getState(){
|
||||
return ep->getState();
|
||||
}
|
||||
|
||||
OverseerHandler::OverseerHandler(QObject *parent) : QObject(parent) {
|
||||
void EndpointHandler::setBackEndpointVolumeCallbackInfoContent(uint8_t state) {
|
||||
if(state == EndpointState::ENDPOINT_ACTIVE) {
|
||||
callbackInfo.muted = this->getMute();
|
||||
callbackInfo.mainVolume = this->getVolume(AudioChannel::CHANNEL_MAIN);
|
||||
callbackInfo.channels = this->getChannelCount();
|
||||
ep->setVolumeCallback(epc);
|
||||
callbackInfo.channelVolumes.resize(this->callbackInfo.channels);
|
||||
for(uint32_t i = 0; i < this->getChannelCount(); i++){
|
||||
callbackInfo.channelVolumes.at(i) = this->getVolume(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void EndpointHandler::setState(uint8_t state){
|
||||
ep->setState(state);
|
||||
this->setBackEndpointVolumeCallbackInfoContent(state);
|
||||
}
|
||||
|
||||
void EndpointHandler::setState(uint8_t state, uint64_t index){
|
||||
ep->setState(state);
|
||||
this->setFrontVisibilityInfo((EndpointState)state, index);
|
||||
this->setBackEndpointVolumeCallbackInfoContent(state);
|
||||
}
|
||||
|
||||
uint8_t EndpointHandler::getRoles(){
|
||||
return ep->getRoles();
|
||||
}
|
||||
|
||||
void EndpointHandler::setRoles(Roles newRole){
|
||||
ep->setRoles(newRole);
|
||||
}
|
||||
|
||||
void EndpointHandler::assignRoles(Roles newRole){
|
||||
ep->assignRoles(newRole);
|
||||
}
|
||||
|
||||
void EndpointHandler::removeRoles(Roles newRole){
|
||||
ep->removeRoles(newRole);
|
||||
}
|
||||
|
||||
void EndpointHandler::setAddSessionWidgetFunction(std::function<void(SessionHandler*)> addSessionWidget) {
|
||||
this->addSessionWidget = addSessionWidget;
|
||||
}
|
||||
|
||||
void EndpointHandler::setRemoveSessionWidgetFunction(std::function<void(SessionHandler*)> removeSessionWidget) {
|
||||
this->removeSessionWidget = removeSessionWidget;
|
||||
}
|
||||
|
||||
/* sessions */
|
||||
size_t EndpointHandler::getSessionCount() {
|
||||
return ep->getSessionCount();
|
||||
}
|
||||
|
||||
std::vector<Session*> EndpointHandler::getSessions(){
|
||||
return ep->getSessions();
|
||||
}
|
||||
|
||||
std::vector<SessionHandler*> EndpointHandler::getSessionHandlers(){
|
||||
return this->sessionHandlers;
|
||||
}
|
||||
|
||||
Endpoint* EndpointHandler::getEndpoint() {
|
||||
return this->ep;
|
||||
}
|
||||
|
||||
void EndpointHandler::addSessionSendFront(Session* session) {
|
||||
ep->addSession(session);
|
||||
|
||||
SessionHandler* sessionHandler = new SessionHandler(this, session, (getSessionCount() - 1));
|
||||
sessionHandlers.push_back(sessionHandler);
|
||||
this->addSessionWidget(sessionHandler);
|
||||
}
|
||||
|
||||
void EndpointHandler::sendSessionToFront(SessionHandler* sh) {
|
||||
this->addSessionWidget(sh);
|
||||
}
|
||||
|
||||
void EndpointHandler::removeSessionFromFront(SessionHandler* sh) {
|
||||
this->removeSessionWidget(sh);
|
||||
}
|
||||
|
||||
EndpointHandler::~EndpointHandler() {
|
||||
ep->removeVolumeCallback(epc);
|
||||
ep->unregisterNewSessionNotification(ensc);
|
||||
epc->Release();
|
||||
delete ep;
|
||||
}
|
||||
|
||||
OverseerHandler::OverseerHandler() {
|
||||
this->os = new Overseer();
|
||||
}
|
||||
|
||||
std::vector<Endpoint*> OverseerHandler::getPlaybackEndpoints() {
|
||||
return this->os->getPlaybackEndpoints();
|
||||
}
|
||||
|
||||
std::vector<Endpoint*> OverseerHandler::getCaptureEndpoints() {
|
||||
return this->os->getCaptureEndpoints();
|
||||
}
|
||||
|
||||
std::vector<EndpointHandler*> OverseerHandler::getPlaybackEndpointHandlers(){
|
||||
return playbackEndpointHandlers;
|
||||
}
|
||||
|
||||
std::vector<EndpointHandler*> OverseerHandler::getCaptureEndpointHandlers(){
|
||||
return captureEndpointHandlers;
|
||||
}
|
||||
|
||||
uint64_t OverseerHandler::getPlaybackEndpointsCount(){
|
||||
return this->os->getPlaybackEndpoints().size();
|
||||
}
|
||||
|
||||
uint64_t OverseerHandler::getCaptureEndpointsCount(){
|
||||
return this->os->getCaptureEndpoints().size();
|
||||
}
|
||||
|
||||
void OverseerHandler::reloadEndpointHandlers(){
|
||||
//todo: add capture
|
||||
|
||||
//std::vector<EndpointHandler*>* ephs = new std::vector<EndpointHandler*>;
|
||||
log_debugcpp("Playback VSize: " + std::to_string(this->getPlaybackEndpointsCount()));
|
||||
|
||||
for(uint64_t i = 0; i < this->getPlaybackEndpointsCount(); i++){
|
||||
log_debugcpp("Creating Playback handler " + std::to_string(i));
|
||||
|
||||
EndpointHandler* ephexx = new EndpointHandler(i, Flows::FLOW_PLAYBACK);
|
||||
//this->playbackEndpointHandlers.push_back(ephexx);
|
||||
log_debugcpp("Created Playback handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->playbackEndpointHandlers.size()));
|
||||
|
||||
}
|
||||
|
||||
log_debugcpp("Capture VSize: " +
|
||||
std::to_string(this->getCaptureEndpointsCount()));
|
||||
|
||||
for(uint64_t i = 0; i < this->getCaptureEndpointsCount(); i++){
|
||||
log_debugcpp("Creating Capture handler " + std::to_string(i));
|
||||
|
||||
/*
|
||||
* if(i < (this->captureEndpointHandlers.size()) &&
|
||||
* this->captureEndpointHandlers.at(i) != nullptr)
|
||||
* delete captureEndpointHandlers.at(i);
|
||||
*/
|
||||
|
||||
EndpointHandler* ephoo = new EndpointHandler(i, Flows::FLOW_CAPTURE);
|
||||
//this->captureEndpointHandlers.push_back(ephoo);
|
||||
log_debugcpp("Created Capture handler " + std::to_string(i) + ", adding to vector. " + " VSize: " + std::to_string(this->captureEndpointHandlers.size()));
|
||||
|
||||
/*
|
||||
* if (i >= this->captureEndpointHandlers.size())
|
||||
* captureEndpointHandlers.push_back(eph);
|
||||
* else captureEndpointHandlers.at(i) = eph;
|
||||
*/
|
||||
}
|
||||
//setEndpointHandlers(ephs);
|
||||
}
|
||||
|
||||
std::vector<EndpointHandler*>* OverseerHandler::getEndpointHandlers(){
|
||||
return endpointHandlers;
|
||||
EndpointHandler* OverseerHandler::addEndpoint(std::wstring endpointId, /* out */ Flows *flow = nullptr){
|
||||
Flows localFlow;
|
||||
Endpoint* newEp = this->os->addEndpoint(endpointId, &localFlow);
|
||||
|
||||
uint64_t ephIdx = (localFlow == Flows::FLOW_PLAYBACK ? this->getPlaybackEndpointsCount() : this->getCaptureEndpointsCount()) - 1;
|
||||
|
||||
EndpointHandler* newEph = new EndpointHandler(ephIdx, localFlow);
|
||||
// std::vector<EndpointHandler*> getPlaybackEndpointHandlers();
|
||||
//std::vector<EndpointHandler*> getCaptureEndpointHandlers();
|
||||
if (flow != nullptr) *flow = localFlow;
|
||||
return newEph;
|
||||
}
|
||||
|
||||
void OverseerHandler::setEndpointHandlers(std::vector<EndpointHandler*> *ephs){
|
||||
this->endpointHandlers = ephs;
|
||||
NGuid OverseerHandler::getGuid() {
|
||||
return this->os->getGuid();
|
||||
}
|
||||
|
||||
void OverseerHandler::setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults){
|
||||
this->changeFrontDefaults = changeFrontDefaults;
|
||||
}
|
||||
|
||||
void OverseerHandler::changeFrontDefaultsCallback(Roles role, std::wstring endpointId) {
|
||||
this->changeFrontDefaults(role, endpointId);
|
||||
}
|
||||
|
||||
void OverseerHandler::reviseEndpointShowing(std::wstring endpointId, EndpointState state) {
|
||||
std::vector<EndpointHandler*> allHandlers;
|
||||
allHandlers.insert(allHandlers.end(), this->captureEndpointHandlers.begin(), this->captureEndpointHandlers.end());
|
||||
allHandlers.insert(allHandlers.end(), this->playbackEndpointHandlers.begin(), this->playbackEndpointHandlers.end());
|
||||
EndpointHandler* eph = nullptr;
|
||||
for (auto loopEph : allHandlers) {
|
||||
if (loopEph->getId() == endpointId) {
|
||||
eph = loopEph;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//debug
|
||||
Flows flow;
|
||||
if (!eph) {
|
||||
if (state ^ EndpointState::ENDPOINT_ACTIVE) return;
|
||||
//return;
|
||||
//flow = Flows::FLOW_CAPTURE;
|
||||
eph = osh->addEndpoint(endpointId, &flow);
|
||||
} else
|
||||
flow = eph->getFlow();
|
||||
|
||||
//todo: mic done but disabled. Tab-kun will come...
|
||||
if (flow == Flows::FLOW_CAPTURE) return;
|
||||
|
||||
|
||||
if(eph && EndpointState::ENDPOINT_ACTIVE & state) {
|
||||
this->addEndpointWidget(eph);
|
||||
} else if (eph && eph->getFrontVisibilityState() == EndpointState::ENDPOINT_ACTIVE){
|
||||
this->removeEndpointWidget(eph->getFrontVisibilityIndex());
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void OverseerHandler::setAddEndpointWidgetFunction(std::function<void(EndpointHandler*)> addEndpointWidget){
|
||||
this->addEndpointWidget = addEndpointWidget;
|
||||
}
|
||||
|
||||
void OverseerHandler::setRemoveEndpointWidgetFunction(std::function<void(uint64_t)> removeEndpointWidget){
|
||||
this->removeEndpointWidget = removeEndpointWidget;
|
||||
}
|
||||
|
||||
void OverseerHandler::setEndpointHandlers(std::vector<EndpointHandler*> ephs){
|
||||
this->playbackEndpointHandlers = ephs;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,48 +1,138 @@
|
|||
#pragma once
|
||||
#include <QObject>
|
||||
#include "backlasses.h"
|
||||
|
||||
#include "global.h"
|
||||
#include "contsessionclasses.h"
|
||||
//#define invoke_mem_fn(object,ptrToMember) ((object).*(ptrToMember))
|
||||
//#define pinvoke_mem_fn(object,ptrToMember) ((object)->*(ptrToMember))
|
||||
|
||||
class EndpointHandler : public QObject {
|
||||
Q_OBJECT
|
||||
class EndpointWidget;
|
||||
class Endpoint;
|
||||
class EndpointVolumeCallback;
|
||||
class Overseer;
|
||||
class SessionHandler;
|
||||
class EndpointNewSessionCallback;
|
||||
|
||||
struct BackEndpointVolumeCallbackInfo {
|
||||
NGuid caller;
|
||||
bool muted;
|
||||
float mainVolume;
|
||||
size_t channels;
|
||||
std::vector<float> channelVolumes;
|
||||
};
|
||||
|
||||
class EndpointHandler {
|
||||
|
||||
public:
|
||||
EndpointHandler(Endpoint *ept, QObject *parent = nullptr);
|
||||
QString getName();
|
||||
EndpointHandler(uint64_t idx, Flows flow);
|
||||
void setBackEndpointVolumeCallbackInfoContent(uint8_t state);
|
||||
|
||||
//these two, currently unused. If I use them, I should feel bad.
|
||||
//EndpointVolumeCallback* getEndpointVolumeCallback();
|
||||
//Endpoint* getEndpoint();
|
||||
|
||||
//std::wstring epName;
|
||||
BackEndpointVolumeCallbackInfo* getCallbackInfo();
|
||||
uint32_t getChannelCount();
|
||||
|
||||
void setIndex(uint64_t idx);
|
||||
uint64_t getIndex();
|
||||
void setVolume(int channel, float volume);
|
||||
|
||||
std::wstring getName();
|
||||
std::wstring getId();
|
||||
|
||||
void setFrontVisibilityInfo(EndpointState state, uint64_t frontIdx);
|
||||
uint64_t getFrontVisibilityIndex();
|
||||
EndpointState getFrontVisibilityState();
|
||||
|
||||
Flows getFlow();
|
||||
float getVolume(int channel);
|
||||
bool getMute();
|
||||
size_t getState();
|
||||
uint8_t getRoles();
|
||||
void setRoles(Roles newRole);
|
||||
void assignRoles(Roles newRole);
|
||||
void removeRoles(Roles newRole);
|
||||
|
||||
void setVolume(NGuid guid, int channel, int value);
|
||||
void setMute(NGuid guid, bool muted);
|
||||
void setState(uint8_t state);
|
||||
void setState(uint8_t state, uint64_t idx);
|
||||
|
||||
/* sessions */
|
||||
size_t getSessionCount();
|
||||
std::vector<SessionHandler*> getSessionHandlers();
|
||||
void createNewSession();
|
||||
Endpoint* getEndpoint();
|
||||
|
||||
/*Session*/
|
||||
void addSessionSendFront(Session* session);
|
||||
void setAddSessionWidgetFunction(std::function<void(SessionHandler*)> addSessionWidget);
|
||||
void setRemoveSessionWidgetFunction(std::function<void(SessionHandler*)> removeSessionWidget);
|
||||
void sendSessionToFront(SessionHandler* sh);
|
||||
void removeSessionFromFront(SessionHandler* sh);
|
||||
|
||||
~EndpointHandler();
|
||||
private:
|
||||
Endpoint *ept;
|
||||
QString eptName;
|
||||
//QSlider *slidy;
|
||||
|
||||
public slots:
|
||||
void setValue(int channel, int value);
|
||||
void setMute();
|
||||
//signals:
|
||||
|
||||
std::vector<Session*> getSessions();
|
||||
|
||||
uint64_t idx;
|
||||
Endpoint *ep = nullptr;
|
||||
EndpointVolumeCallback *epc = nullptr;
|
||||
Flows flow;
|
||||
BackEndpointVolumeCallbackInfo callbackInfo;
|
||||
struct EndpointHandlerFrontVisibility {
|
||||
EndpointState visibility = EndpointState::ENDPOINT_ALL;
|
||||
uint64_t frontIdx = INT_MAX;
|
||||
};
|
||||
EndpointHandlerFrontVisibility ephfv;
|
||||
EndpointNewSessionCallback* ensc;
|
||||
std::vector<SessionHandler*> sessionHandlers;
|
||||
std::function<void(SessionHandler*)> addSessionWidget;
|
||||
std::function<void(SessionHandler*)> removeSessionWidget;
|
||||
//QSlider *slidy;
|
||||
};
|
||||
|
||||
|
||||
class OverseerHandler : public QObject {
|
||||
Q_OBJECT
|
||||
class OverseerHandler {
|
||||
|
||||
public:
|
||||
OverseerHandler(QObject *parent = nullptr);
|
||||
void setEndpointHandlers(std::vector<EndpointHandler*> *ephs);
|
||||
std::vector<EndpointHandler*>* getEndpointHandlers();
|
||||
static Overseer* getOverseer();
|
||||
OverseerHandler();
|
||||
void setChangeFrontDefaultsFunction(std::function<void(Roles, std::wstring)> changeFrontDefaults);
|
||||
void changeFrontDefaultsCallback(Roles role, std::wstring endpointId);
|
||||
|
||||
//void setReviseEndpointShowingFunction(std::function<void(std::wstring, EndpointState)> reviseEndpointShowing);
|
||||
void reviseEndpointShowing(std::wstring endpointId, EndpointState state);
|
||||
void setRemoveEndpointWidgetFunction(std::function<void(uint64_t)> removeEndpointWidget);
|
||||
void setAddEndpointWidgetFunction(std::function<void(EndpointHandler*)> addEndpointWidget);
|
||||
|
||||
void setEndpointHandlers(std::vector<EndpointHandler*> ephs);
|
||||
std::vector<EndpointHandler*> getPlaybackEndpointHandlers();
|
||||
std::vector<EndpointHandler*> getCaptureEndpointHandlers();
|
||||
std::vector<Endpoint*> getPlaybackEndpoints();
|
||||
std::vector<Endpoint*> getCaptureEndpoints();
|
||||
void pushBackEndpointHandler(EndpointHandler* eph, Flows flow);
|
||||
uint64_t getPlaybackEndpointsCount();
|
||||
uint64_t getCaptureEndpointsCount();
|
||||
void reloadEndpointHandlers();
|
||||
EndpointHandler* addEndpoint(std::wstring endpointId, Flows *flow);
|
||||
NGuid getGuid();
|
||||
|
||||
/*
|
||||
* void setSessionVolumeCallback(std::function<void(float)> changeSessionVolume);
|
||||
* void setSessionVolume(float newValue, );
|
||||
*/
|
||||
|
||||
private:
|
||||
static Overseer os;
|
||||
std::vector<EndpointHandler*> *endpointHandlers;
|
||||
//QSlider *slidy;
|
||||
|
||||
//public slots:
|
||||
//void setValue(int value);
|
||||
|
||||
|
||||
Overseer *os;
|
||||
std::vector<EndpointHandler*> playbackEndpointHandlers;
|
||||
std::vector<EndpointHandler*> captureEndpointHandlers;
|
||||
std::function<void(Roles, std::wstring /* endpointid */)> changeFrontDefaults;
|
||||
std::function<void(uint64_t /* epw id */)> removeEndpointWidget;
|
||||
std::function<void(EndpointHandler*)> addEndpointWidget;
|
||||
|
||||
/* Session's */
|
||||
std::function<void(float)> changeSessionVolume;
|
||||
//std::function<void(uint64_t /* device */, uint32_t /* channel */, float /* value */)> updateFrontVolumeCallback;
|
||||
//std::function<void(uint64_t /* device */, bool /* mute */)> updateFrontMuteCallback;
|
||||
|
||||
};
|
||||
|
|
|
|||
79
src/cont/contsessionclasses.cpp
Normal file
79
src/cont/contsessionclasses.cpp
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
#include "contsessionclasses.h"
|
||||
#include "backsessionclasses.h"
|
||||
|
||||
SessionHandler::SessionHandler(EndpointHandler* eph, Session* session, size_t idx) {
|
||||
this->eph = eph;
|
||||
this->idx = idx;
|
||||
this->session = session;
|
||||
|
||||
this->svi.mainVolume = session->getVolume(AudioChannel::CHANNEL_MAIN);
|
||||
this->svi.muted = session->getMute();
|
||||
this->svi.caller = osh->getGuid();
|
||||
|
||||
ssc = new SessionStateCallback(this);
|
||||
this->session->setStateCallback(ssc);
|
||||
}
|
||||
|
||||
void SessionHandler::setVolume(NGuid guid, int channel, int value){
|
||||
if (channel == AudioChannel::CHANNEL_MAIN)
|
||||
session->setVolume(guid, channel, (float)value / 100);
|
||||
else session->setVolume(guid, channel, (float)value / 100);
|
||||
}
|
||||
|
||||
float SessionHandler::getVolume(int channel){
|
||||
return session->getVolume(channel);
|
||||
}
|
||||
|
||||
void SessionHandler::setMute(NGuid guid, bool muted){
|
||||
session->setMute(guid, muted);
|
||||
}
|
||||
|
||||
std::wstring SessionHandler::getName(){
|
||||
return session->getName();
|
||||
}
|
||||
|
||||
bool SessionHandler::getMute(){
|
||||
return session->getMute();
|
||||
}
|
||||
|
||||
void SessionHandler::setFrontIndex(uint64_t frontIdx) {
|
||||
this->frontIdx = frontIdx;
|
||||
}
|
||||
|
||||
uint64_t SessionHandler::getFrontIndex() {
|
||||
return frontIdx;
|
||||
}
|
||||
|
||||
SessionVolumeInfo* SessionHandler::getVolumeInfo() {
|
||||
return &svi;
|
||||
}
|
||||
|
||||
SessionState SessionHandler::getState() {
|
||||
return session->getState();
|
||||
}
|
||||
|
||||
void SessionHandler::setState(SessionState state) {
|
||||
session->setState(state);
|
||||
}
|
||||
|
||||
void SessionHandler::reviseSessionShowing(SessionState state) {
|
||||
SessionState currentState = this->getState();
|
||||
switch (currentState) {
|
||||
case SessionState::ACTIVE:
|
||||
case SessionState::INACTIVE:
|
||||
if (state == SessionState::EXPIRED) {
|
||||
eph->removeSessionFromFront(this);
|
||||
}
|
||||
break;
|
||||
case SessionState::EXPIRED:
|
||||
if (state == SessionState::ACTIVE || INACTIVE) {
|
||||
eph->sendSessionToFront(this);
|
||||
}
|
||||
break;
|
||||
case SessionState::DISCONNECTED:
|
||||
if (frontIdx != INT_MAX)
|
||||
eph->removeSessionFromFront(this);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
42
src/cont/contsessionclasses.h
Normal file
42
src/cont/contsessionclasses.h
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
#pragma once
|
||||
|
||||
#include "global.h"
|
||||
//#include "contclasses.h"
|
||||
|
||||
class EndpointHandler;
|
||||
class Session;
|
||||
class SessionStateCallback;
|
||||
|
||||
struct SessionVolumeInfo {
|
||||
//SessionVolumeInfo(bool muted, float mainVolume);
|
||||
bool muted;
|
||||
float mainVolume;
|
||||
NGuid caller;
|
||||
|
||||
//size_t channels;
|
||||
//std::vector<float> channelVolumes;
|
||||
};
|
||||
|
||||
class SessionHandler {
|
||||
public:
|
||||
SessionHandler(EndpointHandler* eph, Session* session, size_t idx);
|
||||
void setVolume(NGuid guid, int channel, int value);
|
||||
float getVolume(int channel);
|
||||
void setMute(NGuid guid, bool muted);
|
||||
bool getMute();
|
||||
void setFrontIndex(uint64_t frontIdx);
|
||||
SessionState getState();
|
||||
void setState(SessionState state);
|
||||
uint64_t getFrontIndex();
|
||||
std::wstring getName();
|
||||
void reviseSessionShowing(SessionState state);
|
||||
SessionVolumeInfo* getVolumeInfo();
|
||||
|
||||
private:
|
||||
SessionVolumeInfo svi;
|
||||
EndpointHandler* eph;
|
||||
Session* session;
|
||||
SessionStateCallback* ssc;
|
||||
size_t idx;
|
||||
uint64_t frontIdx = INT_MAX;
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue