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         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
  48                         (const QObject*) queue, SLOT(slot_nextTask()));
  49         QObject::connect((const QObject*) m_core->returnReceiver(),
  50                         SIGNAL(signal_ackConnect(genHandle_t, genError_t)),
  51                         (const QObject*) this,
  52                         SLOT(slot_connect_finished(genHandle_t, genError_t)));
  53         m_timer = new QTimer();
  54         m_timer->setSingleShot(true);
  55         QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
  56                         SLOT(slot_timeout()));
  57         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Connect"));
  58         m_timer->start(CONNECT_TIMEOUT);
  59         m_core->connect(m_ParamSource, m_ParamSink, &m_handle);
  60 }
  61
  62 void TaskAsyncConnect::setSink(sink_t sink) {
  63         m_ParamSink = sink;
  64 }
  65
  66 void TaskAsyncConnect::setSource(source_t source) {
  67         m_ParamSource = source;
  68 }
  69
  70 sink_t TaskAsyncConnect::getSink() {
  71         return m_ParamSink;
  72 }
  73
  74 source_t TaskAsyncConnect::getSource() {
  75         return m_ParamSource;
  76 }
  77
  78 void TaskAsyncConnect::slot_connect_finished(genHandle_t handle,
  79                 genError_t error) {
  80         if (handle == m_handle && error == GEN_OK) {
  81                 m_timer->stop();
  82                 delete m_timer;
  83                 m_timer = NULL;
  84                 DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect returned"));
  85                 emit signal_nextTask();
  86         } else {
  87                 DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Somethings wrong with the connection"));
  88         }
  89 }
  90
  91 /**
  92  * \todo handle this event better.
  93  */
  94 void TaskAsyncConnect::slot_timeout() {
  95         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connection timed out"));
  96 }
  97
  98 TaskConnect::TaskConnect(AudioManagerCore* core, sink_t sink, source_t source) :
  99         Task(core), m_ParamSink(sink), m_ParamSource(source) {
 100 }
 101
 102 TaskConnect::~TaskConnect() {
 103 }
 104
 105 void TaskConnect::executeTask(Queue* queue) {
 106         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 107                         (const QObject*) queue, SLOT(slot_nextTask()));
 108         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Syncronous Connect"));
 109         m_core->connect(m_ParamSource, m_ParamSink);
 110         emit signal_nextTask();
 111 }
 112
 113 TaskDisconnect::TaskDisconnect(AudioManagerCore* core, connection_t ID) :
 114         Task(core), m_ParamConnectionID(ID) {
 115 }
 116
 117 TaskDisconnect::~TaskDisconnect() {
 118 }
 119
 120 void TaskDisconnect::executeTask(Queue* queue) {
 121         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 122                         (const QObject*) queue, SLOT(slot_nextTask()));
 123         m_core->disconnect(m_ParamConnectionID);
 124         emit signal_nextTask();
 125 }
 126
 127 TaskInterruptWait::TaskInterruptWait(AudioManagerCore* core,
 128                 genInt_t interruptID) :
 129         Task(core), m_interruptID(interruptID) {
 130 }
 131
 132 TaskInterruptWait::~TaskInterruptWait() {
 133
 134 }
 135
 136 void TaskInterruptWait::executeTask(Queue* queue) {
 137         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 138                         (const QObject*) queue, SLOT(slot_nextTask()));
 139         QObject::connect((const QObject*) m_core->returnCommandInterface(),
 140                         SIGNAL(signal_interruptResume(genInt_t)), (const QObject*) this,
 141                         SLOT(slot_interrupt_ready(genInt_t)));
 142 }
 143
 144 void TaskInterruptWait::slot_interrupt_ready(genInt_t ID) {
 145         if (ID == m_interruptID) {
 146                 emit signal_nextTask();
 147         }
 148 }
 149
 150 TaskSetVolume::TaskSetVolume(AudioManagerCore* core, volume_t newVolume,
 151                 sink_t sink) :
 152         Task(core), m_volume(newVolume), m_sink(sink) {
 153
 154 }
 155
 156 TaskSetVolume::~TaskSetVolume() {
 157 }
 158
 159 void TaskSetVolume::setVolume(volume_t newVolume) {
 160         m_volume = newVolume;
 161 }
 162
 163 void TaskSetVolume::setSink(sink_t sink) {
 164         m_sink = sink;
 165 }
 166
 167 volume_t TaskSetVolume::getVolume() {
 168         return m_volume;
 169 }
 170
 171 sink_t TaskSetVolume::getSink() {
 172         return m_sink;
 173 }
 174
 175 void TaskSetVolume::executeTask(Queue* queue) {
 176         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 177                         (const QObject*) queue, SLOT(slot_nextTask()));
 178         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Volume"));
 179         m_core->setVolume(m_sink, m_volume);
 180         emit signal_nextTask();
 181 }
 182
 183 TaskSetSourceVolume::TaskSetSourceVolume(AudioManagerCore* core,
 184                 volume_t newVolume, source_t source) :
 185         Task(core), m_volume(newVolume), m_source(source) {
 186
 187 }
 188
 189 TaskSetSourceVolume::~TaskSetSourceVolume() {
 190
 191 }
 192
 193 void TaskSetSourceVolume::setVolume(volume_t newVolume) {
 194         m_volume = newVolume;
 195 }
 196
 197 void TaskSetSourceVolume::setSource(source_t source) {
 198         m_source = source;
 199 }
 200
 201 volume_t TaskSetSourceVolume::getVolume() {
 202         return m_volume;
 203 }
 204 source_t TaskSetSourceVolume::getSource() {
 205         return m_source;
 206 }
 207
 208 void TaskSetSourceVolume::executeTask(Queue* queue) {
 209         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 210                         (const QObject*) queue, SLOT(slot_nextTask()));
 211         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Source Volume"));
 212         m_core->setSourceVolume(m_source, m_volume);
 213         emit signal_nextTask();
 214 }
 215
 216 TaskWait::TaskWait(AudioManagerCore* core, int mseconds) :
 217         Task(core), m_ParamMSeconds(mseconds) {
 218 }
 219
 220 TaskWait::~TaskWait() {
 221 }
 222
 223 void TaskWait::setTime(int mseconds) {
 224         m_ParamMSeconds = mseconds;
 225 }
 226
 227 int TaskWait::getTime() {
 228         return m_ParamMSeconds;
 229 }
 230
 231 void TaskWait::executeTask(Queue* queue) {
 232         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 233                         (const QObject*) queue, SLOT(slot_nextTask()));
 234         m_timer = new QTimer();
 235         m_timer->setSingleShot(true);
 236         QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
 237                         SLOT(slot_timeIsup()));
 238         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Start Sleep "));
 239         m_timer->start(m_ParamMSeconds);
 240 }
 241
 242 void TaskWait::slot_timeIsup() {
 243         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Stop Sleep "));
 244         m_timer->stop();
 245         emit signal_nextTask();
 246 }
 247
 248 TaskEnterUserConnect::TaskEnterUserConnect(AudioManagerCore* core,
 249                 genRoute_t route, connection_t connID) :
 250         Task(core), m_route(route), m_connectionID(connID) {
 251 }
 252
 253 TaskEnterUserConnect::~TaskEnterUserConnect() {
 254 }
 255
 256 void TaskEnterUserConnect::setConnection(genRoute_t route, connection_t connID) {
 257         m_route = route;
 258         m_connectionID = connID;
 259 }
 260
 261 genRoute_t TaskEnterUserConnect::returnConnection() {
 262         return m_route;
 263 }
 264
 265 void TaskEnterUserConnect::executeTask(Queue* queue) {
 266         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 267                         (const QObject*) queue, SLOT(slot_nextTask()));
 268         m_core->returnDatabaseHandler()->updateMainConnection(m_connectionID,
 269                         m_route);
 270         emit signal_nextTask();
 271 }
 272
 273 TaskRemoveUserConnect::TaskRemoveUserConnect(AudioManagerCore* core,
 274                 connection_t connID) :
 275         Task(core), m_connectionID(connID) {
 276 }
 277
 278 TaskRemoveUserConnect::~TaskRemoveUserConnect() {
 279
 280 }
 281
 282 void TaskRemoveUserConnect::setConnectionID(connection_t connID) {
 283         m_connectionID = connID;
 284 }
 285
 286 connection_t TaskRemoveUserConnect::returnConnectionID() {
 287         return m_connectionID;
 288 }
 289
 290 void TaskRemoveUserConnect::executeTask(Queue* queue) {
 291         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 292                         (const QObject*) queue, SLOT(slot_nextTask()));
 293         m_core->returnDatabaseHandler()->removeMainConnection(m_connectionID);
 294         emit signal_nextTask();
 295 }
 296
 297 TaskEnterInterrupt::TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,
 298                 bool mixed, connection_t connID, QList<source_t> listInterruptedSources) :
 299         Task(core), m_intID(ID), m_mixed(mixed), m_connectionID(connID),
 300                         m_interruptedSourcesList(listInterruptedSources) {
 301 }
 302
 303 TaskEnterInterrupt::~TaskEnterInterrupt() {
 304 }
 305
 306 void TaskEnterInterrupt::executeTask(Queue* queue) {
 307         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 308                         (const QObject*) queue, SLOT(slot_nextTask()));
 309         m_core->returnDatabaseHandler()->updateInterrupt(m_intID, m_connectionID,
 310                         m_mixed, m_interruptedSourcesList);
 311         emit signal_nextTask();
 312 }
 313
 314 TaskRemoveInterrupt::TaskRemoveInterrupt(AudioManagerCore* core, genInt_t ID) :
 315         Task(core), m_intID(ID) {
 316 }
 317
 318 TaskRemoveInterrupt::~TaskRemoveInterrupt() {
 319 }
 320
 321 void TaskRemoveInterrupt::executeTask(Queue* queue) {
 322         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 323                         (const QObject*) queue, SLOT(slot_nextTask()));
 324         m_core->returnDatabaseHandler()->removeInterrupt(m_intID);
 325         emit signal_nextTask();
 326 }
 327
 328 TaskSetSourceMute::TaskSetSourceMute(AudioManagerCore* core, source_t source) :
 329         Task(core), m_source(source) {
 330 }
 331
 332 TaskSetSourceMute::~TaskSetSourceMute() {
 333 }
 334
 335 void TaskSetSourceMute::executeTask(Queue* queue) {
 336         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 337                         (const QObject*) queue, SLOT(slot_nextTask()));
 338         m_core->setSourceMute(m_source);
 339         emit signal_nextTask();
 340 }
 341
 342 TaskSetSourceUnmute::TaskSetSourceUnmute(AudioManagerCore* core,
 343                 source_t source) :
 344         Task(core), m_source(source) {
 345 }
 346
 347 TaskSetSourceUnmute::~TaskSetSourceUnmute() {
 348 }
 349
 350 void TaskSetSourceUnmute::executeTask(Queue* queue) {
 351         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 352                         (const QObject*) queue, SLOT(slot_nextTask()));
 353         m_core->setSourceUnMute(m_source);
 354         emit signal_nextTask();
 355 }
 356
 357 TaskEmitSignalConnect::TaskEmitSignalConnect(AudioManagerCore* core) :
 358         Task(core) {
 359 }
 360
 361 TaskEmitSignalConnect::~TaskEmitSignalConnect() {
 362 }
 363
 364 void TaskEmitSignalConnect::executeTask(Queue* queue) {
 365         QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
 366                         (const QObject*) queue, SLOT(slot_nextTask()));
 367         m_core->emitSignalConnect();
 368         emit signal_nextTask();
 369 }
 370
 371 Queue::Queue(AudioManagerCore* core, QString name) :
 372         m_core(core), m_currentIndex(0), m_name(name), m_taskList(QList<Task*> ()) {
 373         m_core->addQueue(this);
 374 }
 375
 376 Queue::~Queue() {
 377         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("shoot all tasks"));
 378         foreach (Task* task, m_taskList) {
 379                 delete task;
 380         }
 381         m_core->removeQueue(this);
 382 }
 383
 384 void Queue::run() {
 385         if (m_taskList.isEmpty() == false) {
 386                 Task* task = m_taskList.first();
 387                 DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started to execute Task"));
 388                 task->executeTask(this);
 389         } else {
 390                 DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("empty tasklist was attempted to run "));
 391         }
 392
 393 }
 394
 395 void Queue::slot_nextTask() {
 396         m_currentIndex++;
 397         if (m_currentIndex < m_taskList.length()) {
 398                 DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Task "),DLT_INT(m_currentIndex),DLT_STRING(" out of ") ,DLT_INT(m_taskList.length()));
 399                 m_taskList.at(m_currentIndex)->executeTask(this);
 400         } else {
 401                 DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Finished all Tasks"));
 402                 this->~Queue();
 403         }
 404 }
 405
 406 void Queue::addTask(Task* task) {
 407         m_taskList.append(task);
 408 }
 409
 410 genError_t Queue::removeTask(Task* task) {
 411         if (m_taskList.removeAll(task) > 0) {
 412                 return GEN_OK;
 413         }
 414         return GEN_OUTOFRANGE;
 415         void addQueue(Queue* queue);
 416
 417 }
 418
 419 QList<Task*> Queue::getTaskList() {
 420         return m_taskList;
 421 }
 422
 423 QString Queue::returnName() {
 424         return m_name;
 425 }
 426
 427 AudioManagerCore::AudioManagerCore() :
 428         m_queueList(QList<Queue*> ()) {
 429 }
 430
 431 AudioManagerCore::~AudioManagerCore() {
 432         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("delete all running queues"));
 433         foreach (Queue* queue, m_queueList) {
 434                 delete queue;
 435         }
 436 }
 437
 438 Router* AudioManagerCore::returnRouter() {
 439         return m_router;
 440 }
 441
 442 DataBaseHandler* AudioManagerCore::returnDatabaseHandler() {
 443         return m_databaseHandler;
 444 }
 445
 446 RoutingReceiver* AudioManagerCore::returnReceiver() {
 447         return m_receiver;
 448 }
 449
 450 DBusCommandInterface* AudioManagerCore::returnCommandInterface() {
 451         return m_command;
 452 }
 453
 454 void AudioManagerCore::registerBushandler(Bushandler* handler) {
 455         m_busHandler = handler;
 456 }
 457
 458 void AudioManagerCore::registerDatabasehandler(DataBaseHandler* handler) {
 459         m_databaseHandler = handler;
 460 }
 461
 462 void AudioManagerCore::registerRouter(Router* router) {
 463         m_router = router;
 464 }
 465
 466 void AudioManagerCore::registerHookEngine(HookHandler* handler) {
 467         m_hookHandler = handler;
 468 }
 469
 470 void AudioManagerCore::registerReceiver(RoutingReceiver* receiver) {
 471         m_receiver = receiver;
 472 }
 473
 474 void AudioManagerCore::registerCommandInterface(DBusCommandInterface* command) {
 475         m_command = command;
 476 }
 477
 478 genError_t AudioManagerCore::UserConnect(source_t source, sink_t sink) {
 479         Queue* userConnectionRequestQ = new Queue(this, "User Connect");
 480         m_hookHandler->fireHookUserConnectionRequest(userConnectionRequestQ,
 481                         source, sink);
 482         userConnectionRequestQ->run();
 483         return GEN_OK;
 484 }
 485
 486 genError_t AudioManagerCore::UserDisconnect(connection_t connID) {
 487         Queue* userDisconnectionRequestQ = new Queue(this, "User Disconnect");
 488         m_hookHandler->fireHookUserDisconnectionRequest(userDisconnectionRequestQ,
 489                         connID);
 490         userDisconnectionRequestQ->run();
 491         return GEN_OK;
 492 }
 493
 494 genError_t AudioManagerCore::UserSetVolume(sink_t sink, volume_t volume) {
 495         m_hookHandler->fireHookVolumeChange(volume, sink);
 496         return GEN_OK;
 497 }
 498
 499 QList<ConnectionType> AudioManagerCore::getListConnections() {
 500         return m_databaseHandler->getListAllMainConnections();
 501 }
 502
 503 QList<SinkType> AudioManagerCore::getListSinks() {
 504         QList<SinkType> sinkList;
 505         m_databaseHandler->getListofSinks(&sinkList);
 506         return sinkList;
 507 }
 508
 509 QList<SourceType> AudioManagerCore::getListSources() {
 510         QList<SourceType> sourceList;
 511         m_databaseHandler->getListofSources(&sourceList);
 512         return sourceList;
 513 }
 514
 515 void AudioManagerCore::emitSignalConnect() {
 516         emit signal_connectionChanged();
 517 }
 518
 519 genError_t AudioManagerCore::connect(source_t source, sink_t sink,
 520                 genHandle_t* handle) {
 521         genHandle_t localhandle;
 522         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect"), DLT_INT(source), DLT_STRING(" to "), DLT_INT(sink));
 523         domain_t domainID = m_databaseHandler->get_Domain_ID_from_Source_ID(source);
 524         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 525                         m_databaseHandler->get_Bus_from_Domain_ID(domainID));
 526         localhandle = m_databaseHandler->insertConnection(source, sink);
 527
 528         if (handle) {
 529                 *handle = localhandle;
 530         }
 531         iface->connect(source, sink, localhandle);
 532         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect finished"));
 533         return GEN_OK;
 534         /**
 535          * \todo implement error handling
 536          */
 537 }
 538
 539 genError_t AudioManagerCore::disconnect(connection_t ID) {
 540         domain_t domainID = m_databaseHandler->get_Domain_ID_from_Connection_ID(ID);
 541         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 542                         m_databaseHandler->get_Bus_from_Domain_ID(domainID));
 543         iface->disconnect(ID);
 544         m_databaseHandler->removeConnection(ID);
 545         return GEN_OK;
 546         /**
 547          * \todo failure handling
 548          */
 549 }
 550
 551 genError_t AudioManagerCore::setVolume(sink_t sink, volume_t volume) {
 552         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 553                         m_databaseHandler->get_Bus_from_Domain_ID(
 554                                         m_databaseHandler->get_Domain_ID_from_Sink_ID(sink)));
 555         iface->setSinkVolume(volume, sink);
 556         return GEN_OK;
 557         /**
 558          * \todo failure handling
 559          */
 560 }
 561
 562 genError_t AudioManagerCore::interruptRequest(source_t interruptSource,
 563                 sink_t sink, genInt_t* interrupt) {
 564         Queue* interruptRequestQ = new Queue(this, "Interrupt Request");
 565         m_hookHandler->fireHookInterruptRequest(interruptRequestQ, interruptSource,
 566                         sink, interrupt);
 567         interruptRequestQ->run();
 568         return GEN_OK;
 569 }
 570
 571 genError_t AudioManagerCore::setSourceVolume(source_t source, volume_t volume) {
 572         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 573                         m_databaseHandler->get_Bus_from_Domain_ID(
 574                                         m_databaseHandler->get_Domain_ID_from_Source_ID(source)));
 575         iface->setSourceVolume(volume, source);
 576         return GEN_OK;
 577 }
 578
 579 genError_t AudioManagerCore::setSourceMute(source_t source) {
 580         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 581                         m_databaseHandler->get_Bus_from_Domain_ID(
 582                                         m_databaseHandler->get_Domain_ID_from_Source_ID(source)));
 583         iface->muteSource(source);
 584         return GEN_OK;
 585 }
 586
 587 genError_t AudioManagerCore::setSourceUnMute(source_t source) {
 588         RoutingSendInterface* iface = m_busHandler->getInterfaceforBus(
 589                         m_databaseHandler->get_Bus_from_Domain_ID(
 590                                         m_databaseHandler->get_Domain_ID_from_Source_ID(source)));
 591         iface->unmuteSource(source);
 592         return GEN_OK;
 593 }
 594
 595 genError_t AudioManagerCore::getRoute(const bool onlyfree,
 596                 const source_t source, const sink_t sink, QList<genRoute_t>* ReturnList) {
 597         m_hookHandler->fireHookRoutingRequest(onlyfree, source, sink, ReturnList);
 598         return GEN_OK;
 599 }
 600
 601 connection_t AudioManagerCore::returnConnectionIDforSinkSource(sink_t sink,
 602                 source_t source) {
 603         return m_databaseHandler->getConnectionID(source, sink);
 604 }
 605
 606 genError_t AudioManagerCore::removeQueue(Queue* queue) {
 607         if (m_queueList.removeAll(queue)) {
 608                 return GEN_OK;
 609         } else {
 610                 return GEN_OUTOFRANGE;
 611         }
 612 }
 613
 614 source_t AudioManagerCore::returnSourceIDfromName(const QString name) {
 615         return m_databaseHandler->get_Source_ID_from_Name(name);
 616 }
 617
 618 sink_t AudioManagerCore::returnSinkIDfromName(const QString name) {
 619         return m_databaseHandler->get_Sink_ID_from_Name(name);
 620 }
 621
 622 void AudioManagerCore::addQueue(Queue* queue) {
 623         m_queueList.append(queue);
 624 }
 625