AudioManagerDaemon/AudioManagerCore.cpp

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * AudioManangerDeamon
   5  *
   6  * \file AudioManagerCore.cpp
   7  *
   8  * \date 20.05.2011
   9  * \author Christian Müller (christian.ei.mueller@bmw.de)
  10  *
  11  * \section License
  12  * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  13  * Copyright (C) 2011, BMW AG – Christian Müller  Christian.ei.mueller@bmw.de
  14  *
  15  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
  16  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
  17  * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
  18  * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
  19  * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
  20  * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
  21  * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
  22  *
  23  *
  24  */
  25
  26 #include "AudioManagerCore.h"
  27
  28 Task::Task() {
  29 }
  30
  31 Task::~Task() {
  32 }
  33
  34 Task::Task(AudioManagerCore* core) {
  35         m_core = core;
  36 }
  37
  38 TaskAsyncConnect::TaskAsyncConnect(AudioManagerCore* core, sink_t sink,
  39                 source_t source) :
  40         Task(core), m_ParamSink(sink), m_ParamSource(source) {
  41 }
  42
  43 TaskAsyncConnect::~TaskAsyncConnect() {
  44 }
  45
  46 void TaskAsyncConnect::executeTask(Queue* queue) {
  47         /**
  48          * \todo remove signals and slots, change to non QT timers
  49          */
  50 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
  51 //                      (const QObject*) queue, SLOT(slot_nextTask()));
  52 //      QObject::connect((const QObject*) m_core->returnReceiver(),
  53 //                      SIGNAL(signal_ackConnect(genHandle_t, genError_t)),
  54 //                      (const QObject*) this,
  55 //                      SLOT(slot_connect_finished(genHandle_t, genError_t)));
  56 //      m_timer = new QTimer();
  57 //      m_timer->setSingleShot(true);
  58 //      QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
  59 //                      SLOT(slot_timeout()));
  60 //      DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Connect"));
  61 //      m_timer->start(CONNECT_TIMEOUT);
  62         m_core->connect(m_ParamSource, m_ParamSink, &m_handle);
  63 }
  64
  65 void TaskAsyncConnect::setSink(sink_t sink) {
  66         m_ParamSink = sink;
  67 }
  68
  69 void TaskAsyncConnect::setSource(source_t source) {
  70         m_ParamSource = source;
  71 }
  72
  73 sink_t TaskAsyncConnect::getSink() {
  74         return m_ParamSink;
  75 }
  76
  77 source_t TaskAsyncConnect::getSource() {
  78         return m_ParamSource;
  79 }
  80
  81 void TaskAsyncConnect::slot_connect_finished(genHandle_t handle,
  82                 genError_t error) {
  83 //      if (handle == m_handle && error == GEN_OK) {
  84 //              m_timer->stop();
  85 //              delete m_timer;
  86 //              m_timer = NULL;
  87 //              DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect returned"));
  88 //              emit signal_nextTask();
  89 //      } else {
  90 //              DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Somethings wrong with the connection"));
  91 //      }
  92 }
  93
  94 /**
  95  * \todo handle this event better.
  96  */
  97 void TaskAsyncConnect::slot_timeout() {
  98         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connection timed out"));
  99 }
 100
 101 TaskConnect::TaskConnect(AudioManagerCore* core, sink_t sink, source_t source) :
 102         Task(core), m_ParamSink(sink), m_ParamSource(source) {
 103 }
 104
 105 TaskConnect::~TaskConnect() {
 106 }
 107
 108 void TaskConnect::executeTask(Queue* queue) {
 109 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 110 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 111 //      DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Syncronous Connect"));
 112         m_core->connect(m_ParamSource, m_ParamSink);
 113         //emit signal_nextTask();
 114 }
 115
 116 TaskDisconnect::TaskDisconnect(AudioManagerCore* core, connection_t ID) :
 117         Task(core), m_ParamConnectionID(ID) {
 118 }
 119
 120 TaskDisconnect::~TaskDisconnect() {
 121 }
 122
 123 void TaskDisconnect::executeTask(Queue* queue) {
 124 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 125 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 126         m_core->disconnect(m_ParamConnectionID);
 127 //      emit signal_nextTask();
 128 }
 129
 130 TaskInterruptWait::TaskInterruptWait(AudioManagerCore* core,
 131                 genInt_t interruptID) :
 132         Task(core), m_interruptID(interruptID) {
 133 }
 134
 135 TaskInterruptWait::~TaskInterruptWait() {
 136
 137 }
 138
 139 void TaskInterruptWait::executeTask(Queue* queue) {
 140 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 141 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 142 //      QObject::connect((const QObject*) m_core->returnCommandInterface(),
 143 //                      SIGNAL(signal_interruptResume(genInt_t)), (const QObject*) this,
 144 //                      SLOT(slot_interrupt_ready(genInt_t)));
 145 }
 146
 147 void TaskInterruptWait::slot_interrupt_ready(genInt_t ID) {
 148         if (ID == m_interruptID) {
 149                 //emit signal_nextTask();
 150         }
 151 }
 152
 153 TaskSetVolume::TaskSetVolume(AudioManagerCore* core, volume_t newVolume,
 154                 sink_t sink) :
 155         Task(core), m_volume(newVolume), m_sink(sink) {
 156
 157 }
 158
 159 TaskSetVolume::~TaskSetVolume() {
 160 }
 161
 162 void TaskSetVolume::setVolume(volume_t newVolume) {
 163         m_volume = newVolume;
 164 }
 165
 166 void TaskSetVolume::setSink(sink_t sink) {
 167         m_sink = sink;
 168 }
 169
 170 volume_t TaskSetVolume::getVolume() {
 171         return m_volume;
 172 }
 173
 174 sink_t TaskSetVolume::getSink() {
 175         return m_sink;
 176 }
 177
 178 void TaskSetVolume::executeTask(Queue* queue) {
 179 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 180 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 181 //      DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Volume"));
 182         m_core->setVolume(m_sink, m_volume);
 183 //      emit signal_nextTask();
 184 }
 185
 186 TaskSetSourceVolume::TaskSetSourceVolume(AudioManagerCore* core,
 187                 volume_t newVolume, source_t source) :
 188         Task(core), m_volume(newVolume), m_source(source) {
 189
 190 }
 191
 192 TaskSetSourceVolume::~TaskSetSourceVolume() {
 193
 194 }
 195
 196 void TaskSetSourceVolume::setVolume(volume_t newVolume) {
 197         m_volume = newVolume;
 198 }
 199
 200 void TaskSetSourceVolume::setSource(source_t source) {
 201         m_source = source;
 202 }
 203
 204 volume_t TaskSetSourceVolume::getVolume() {
 205         return m_volume;
 206 }
 207 source_t TaskSetSourceVolume::getSource() {
 208         return m_source;
 209 }
 210
 211 void TaskSetSourceVolume::executeTask(Queue* queue) {
 212 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 213 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 214         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Source Volume"));
 215         m_core->setSourceVolume(m_source, m_volume);
 216 //      emit signal_nextTask();
 217 }
 218
 219 TaskWait::TaskWait(AudioManagerCore* core, int mseconds) :
 220         Task(core), m_ParamMSeconds(mseconds) {
 221 }
 222
 223 TaskWait::~TaskWait() {
 224 }
 225
 226 void TaskWait::setTime(int mseconds) {
 227         m_ParamMSeconds = mseconds;
 228 }
 229
 230 int TaskWait::getTime() {
 231         return m_ParamMSeconds;
 232 }
 233
 234 void TaskWait::executeTask(Queue* queue) {
 235 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 236 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 237 //      m_timer = new QTimer();
 238 //      m_timer->setSingleShot(true);
 239 //      QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
 240 //                      SLOT(slot_timeIsup()));
 241         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Start Sleep "));
 242 //      m_timer->start(m_ParamMSeconds);
 243 }
 244
 245 void TaskWait::slot_timeIsup() {
 246         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Stop Sleep "));
 247 //      m_timer->stop();
 248 //      emit signal_nextTask();
 249 }
 250
 251 TaskEnterUserConnect::TaskEnterUserConnect(AudioManagerCore* core,
 252                 genRoute_t route, connection_t connID) :
 253         Task(core), m_route(route), m_connectionID(connID) {
 254 }
 255
 256 TaskEnterUserConnect::~TaskEnterUserConnect() {
 257 }
 258
 259 void TaskEnterUserConnect::setConnection(genRoute_t route, connection_t connID) {
 260         m_route = route;
 261         m_connectionID = connID;
 262 }
 263
 264 genRoute_t TaskEnterUserConnect::returnConnection() {
 265         return m_route;
 266 }
 267
 268 void TaskEnterUserConnect::executeTask(Queue* queue) {
 269 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 270 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 271         m_core->returnDatabaseHandler()->updateMainConnection(m_connectionID,
 272                         m_route);
 273 //      emit signal_nextTask();
 274 }
 275
 276 TaskRemoveUserConnect::TaskRemoveUserConnect(AudioManagerCore* core,
 277                 connection_t connID) :
 278         Task(core), m_connectionID(connID) {
 279 }
 280
 281 TaskRemoveUserConnect::~TaskRemoveUserConnect() {
 282
 283 }
 284
 285 void TaskRemoveUserConnect::setConnectionID(connection_t connID) {
 286         m_connectionID = connID;
 287 }
 288
 289 connection_t TaskRemoveUserConnect::returnConnectionID() {
 290         return m_connectionID;
 291 }
 292
 293 void TaskRemoveUserConnect::executeTask(Queue* queue) {
 294 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 295 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 296         m_core->returnDatabaseHandler()->removeMainConnection(m_connectionID);
 297 //      emit signal_nextTask();
 298 }
 299
 300 TaskEnterInterrupt::TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,
 301                 bool mixed, connection_t connID, std::list<source_t> listInterruptedSources) :
 302         Task(core), m_intID(ID), m_mixed(mixed), m_connectionID(connID),
 303                         m_interruptedSourcesList(listInterruptedSources) {
 304 }
 305
 306 TaskEnterInterrupt::~TaskEnterInterrupt() {
 307 }
 308
 309 void TaskEnterInterrupt::executeTask(Queue* queue) {
 310 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 311 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 312         m_core->returnDatabaseHandler()->updateInterrupt(m_intID, m_connectionID,
 313                         m_mixed, m_interruptedSourcesList);
 314 //      emit signal_nextTask();
 315 }
 316
 317 TaskRemoveInterrupt::TaskRemoveInterrupt(AudioManagerCore* core, genInt_t ID) :
 318         Task(core), m_intID(ID) {
 319 }
 320
 321 TaskRemoveInterrupt::~TaskRemoveInterrupt() {
 322 }
 323
 324 void TaskRemoveInterrupt::executeTask(Queue* queue) {
 325 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 326 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 327         m_core->returnDatabaseHandler()->removeInterrupt(m_intID);
 328 //      emit signal_nextTask();
 329 }
 330
 331 TaskSetSourceMute::TaskSetSourceMute(AudioManagerCore* core, source_t source) :
 332         Task(core), m_source(source) {
 333 }
 334
 335 TaskSetSourceMute::~TaskSetSourceMute() {
 336 }
 337
 338 void TaskSetSourceMute::executeTask(Queue* queue) {
 339 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 340 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 341         m_core->setSourceMute(m_source);
 342 //      emit signal_nextTask();
 343 }
 344
 345 TaskSetSourceUnmute::TaskSetSourceUnmute(AudioManagerCore* core,
 346                 source_t source) :
 347         Task(core), m_source(source) {
 348 }
 349
 350 TaskSetSourceUnmute::~TaskSetSourceUnmute() {
 351 }
 352
 353 void TaskSetSourceUnmute::executeTask(Queue* queue) {
 354 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 355 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 356         m_core->setSourceUnMute(m_source);
 357 //      emit signal_nextTask();
 358 }
 359
 360 TaskEmitSignalConnect::TaskEmitSignalConnect(AudioManagerCore* core) :
 361         Task(core) {
 362 }
 363
 364 TaskEmitSignalConnect::~TaskEmitSignalConnect() {
 365 }
 366
 367 void TaskEmitSignalConnect::executeTask(Queue* queue) {
 368 //      QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 369 //                      (const QObject*) queue, SLOT(slot_nextTask()));
 370         m_core->emitSignalConnect();
 371 //      emit signal_nextTask();
 372 }
 373
 374 Queue::Queue(AudioManagerCore* core, std::string name) :
 375         m_core(core), m_currentIndex(0), m_name(name), m_taskList(std::list<Task*> ()) {
 376         m_core->addQueue(this);
 377 }
 378
 379 Queue::~Queue() {
 380         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("shoot all tasks"));
 381 //      foreach (Task* task, m_taskList) {
 382 //              delete task;
 383 //      }
 384         m_core->removeQueue(this);
 385 }
 386
 387 void Queue::run() {
 388         if (m_taskList.empty() == false) {
 389                 Task* task = m_taskList.front();
 390                 DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started to execute Task"));
 391                 task->executeTask(this);
 392         } else {
 393                 DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("empty tasklist was attempted to run "));
 394         }
 395
 396 }
 397
 398 void Queue::slot_nextTask() {
 399         m_currentIndex++;
 400 //      if (m_currentIndex < m_taskList.size()) {
 401 //              //m_currentIndex->executeTask(*this);
 402 //      } else {
 403 //              DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Finished all Tasks"));
 404 //              this->~Queue();
 405 //      }
 406 }
 407
 408 void Queue::addTask(Task* task) {
 409         m_taskList.push_back(task);
 410 }
 411
 412 genError_t Queue::removeTask(Task* task) {
 413 //      if (m_taskList.remove(task) > 0) {
 414 //              return GEN_OK;
 415 //      }
 416         return GEN_OUTOFRANGE;
 417         void addQueue(Queue* queue);
 418
 419 }
 420
 421 std::list<Task*> Queue::getTaskList() {
 422         return m_taskList;
 423 }
 424
 425 std::string Queue::returnName() {
 426         return m_name;
 427 }
 428
 429 AudioManagerCore::AudioManagerCore() :
 430         m_queueList(std::list<Queue*> ()) {
 431 }
 432
 433 AudioManagerCore::~AudioManagerCore() {
 434         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("delete all running queues"));
 435         std::list<Queue*>::iterator qIterator;
 436         for(qIterator=m_queueList.begin();qIterator!=m_queueList.end();qIterator++) {
 437                 delete *qIterator;
 438         }
 439 }
 440
 441 Router* AudioManagerCore::returnRouter() {
 442         return m_router;
 443 }
 444
 445 DataBaseHandler* AudioManagerCore::returnDatabaseHandler() {
 446         return m_databaseHandler;
 447 }
 448
 449 RoutingReceiver* AudioManagerCore::returnReceiver() {
 450         return m_receiver;
 451 }
 452
 453 DBusCommandInterface* AudioManagerCore::returnCommandInterface() {
 454         return m_command;
 455 }
 456
 457 void AudioManagerCore::registerBushandler(Bushandler* handler) {
 458         m_busHandler = handler;
 459 }
 460
 461 void AudioManagerCore::registerDatabasehandler(DataBaseHandler* handler) {
 462         m_databaseHandler = handler;
 463 }
 464
 465 void AudioManagerCore::registerRouter(Router* router) {
 466         m_router = router;
 467 }
 468
 469 void AudioManagerCore::registerHookEngine(HookHandler* handler) {
 470         m_hookHandler = handler;
 471 }
 472
 473 void AudioManagerCore::registerReceiver(RoutingReceiver* receiver) {
 474         m_receiver = receiver;
 475 }
 476
 477 void AudioManagerCore::registerCommandInterface(DBusCommandInterface* command) {
 478         m_command = command;
 479 }
 480
 481 genError_t AudioManagerCore::UserConnect(source_t source, sink_t sink) {
 482         Queue* userConnectionRequestQ = new Queue(this, "User Connect");
 483         m_hookHandler->fireHookUserConnectionRequest(userConnectionRequestQ,
 484                         source, sink);
 485         userConnectionRequestQ->run();
 486         return GEN_OK;
 487 }
 488
 489 genError_t AudioManagerCore::UserDisconnect(connection_t connID) {
 490         Queue* userDisconnectionRequestQ = new Queue(this, "User Disconnect");
 491         m_hookHandler->fireHookUserDisconnectionRequest(userDisconnectionRequestQ,
 492                         connID);
 493         userDisconnectionRequestQ->run();
 494         return GEN_OK;
 495 }
 496
 497 genError_t AudioManagerCore::UserSetVolume(sink_t sink, volume_t volume) {
 498         m_hookHandler->fireHookVolumeChange(volume, sink);
 499         return GEN_OK;
 500 }
 501
 502 std::list<ConnectionType> AudioManagerCore::getListConnections() {
 503         return m_databaseHandler->getListAllMainConnections();
 504 }
 505
 506 std::list<SinkType> AudioManagerCore::getListSinks() {
 507         std::list<SinkType> sinkList;
 508         m_databaseHandler->getListofSinks(&sinkList);
 509         return sinkList;
 510 }
 511
 512 std::list<SourceType> AudioManagerCore::getListSources() {
 513         std::list<SourceType> sourceList;
 514         m_databaseHandler->getListofSources(&sourceList);
 515         return sourceList;
 516 }
 517
 518 void AudioManagerCore::emitSignalConnect() {
 519 //      emit signal_connecionChanged();
 520 }
 521
 522 genError_t AudioManagerCore::connect(source_t source, sink_t sink,
 523                 genHandle_t* handle) {
 524         genHandle_t localhandle;
 525         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect"), DLT_INT(source), DLT_STRING(" to "), DLT_INT(sink));
 526         domain_t domainID = m_databaseHandler->get_Domain_ID_from_Source_ID(source);
 527         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 528                         m_databaseHandler->get_Bus_from_Domain_ID(domainID));
 529         localhandle = m_databaseHandler->insertConnection(source, sink);
 530
 531         if (handle) {
 532                 *handle = localhandle;
 533         }
 534         iface->connect(source, sink, localhandle);
 535         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect finished"));
 536         return GEN_OK;
 537         /**
 538          * \todo implement error handling
 539          */
 540 }
 541
 542 genError_t AudioManagerCore::disconnect(connection_t ID) {
 543         domain_t domainID = m_databaseHandler->get_Domain_ID_from_Connection_ID(ID);
 544         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 545                         m_databaseHandler->get_Bus_from_Domain_ID(domainID));
 546         iface->disconnect(ID);
 547         m_databaseHandler->removeConnection(ID);
 548         return GEN_OK;
 549         /**
 550          * \todo failure handling
 551          */
 552 }
 553
 554 genError_t AudioManagerCore::setVolume(sink_t sink, volume_t volume) {
 555         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 556                         m_databaseHandler->get_Bus_from_Domain_ID(
 557                                         m_databaseHandler->get_Domain_ID_from_Sink_ID(sink)));
 558         iface->setSinkVolume(volume, sink);
 559         return GEN_OK;
 560         /**
 561          * \todo failure handling
 562          */
 563 }
 564
 565 genError_t AudioManagerCore::interruptRequest(source_t interruptSource,
 566                 sink_t sink, genInt_t* interrupt) {
 567         Queue* interruptRequestQ = new Queue(this, "Interrupt Request");
 568         m_hookHandler->fireHookInterruptRequest(interruptRequestQ, interruptSource,
 569                         sink, interrupt);
 570         interruptRequestQ->run();
 571         return GEN_OK;
 572 }
 573
 574 genError_t AudioManagerCore::setSourceVolume(source_t source, volume_t volume) {
 575         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 576                         m_databaseHandler->get_Bus_from_Domain_ID(
 577                                         m_databaseHandler->get_Domain_ID_from_Source_ID(source)));
 578         iface->setSourceVolume(volume, source);
 579         return GEN_OK;
 580 }
 581
 582 genError_t AudioManagerCore::setSourceMute(source_t source) {
 583         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 584                         m_databaseHandler->get_Bus_from_Domain_ID(
 585                                         m_databaseHandler->get_Domain_ID_from_Source_ID(source)));
 586         iface->muteSource(source);
 587         return GEN_OK;
 588 }
 589
 590 genError_t AudioManagerCore::setSourceUnMute(source_t source) {
 591         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 592                         m_databaseHandler->get_Bus_from_Domain_ID(
 593                                         m_databaseHandler->get_Domain_ID_from_Source_ID(source)));
 594         iface->unmuteSource(source);
 595         return GEN_OK;
 596 }
 597
 598 genError_t AudioManagerCore::getRoute(const bool onlyfree,
 599                 const source_t source, const sink_t sink, std::list<genRoute_t>* ReturnList) {
 600         m_hookHandler->fireHookRoutingRequest(onlyfree, source, sink, ReturnList);
 601         return GEN_OK;
 602 }
 603
 604 connection_t AudioManagerCore::returnConnectionIDforSinkSource(sink_t sink,
 605                 source_t source) {
 606         return m_databaseHandler->getConnectionID(source, sink);
 607 }
 608
 609 genError_t AudioManagerCore::removeQueue(Queue* queue) {
 610 //      if (m_queueList.remove(*queue)) {
 611 //              return GEN_OK;
 612 //      } else {
 613 //              return GEN_OUTOFRANGE;
 614 //      }
 615 }
 616
 617 source_t AudioManagerCore::returnSourceIDfromName(const std::string name) {
 618         return m_databaseHandler->get_Source_ID_from_Name(name);
 619 }
 620
 621 sink_t AudioManagerCore::returnSinkIDfromName(const std::string name) {
 622         return m_databaseHandler->get_Sink_ID_from_Name(name);
 623 }
 624
 625 void AudioManagerCore::addQueue(Queue* queue) {
 626         m_queueList.push_back(queue);
 627 }
 628