AudioManagerDaemon/AudioManagerCore.h

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * AudioManangerDeamon
   5  *
   6  * \file AudioManagerCore.h
   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 #ifndef AUDIOMANAGERCORE_H_
  27 #define AUDIOMANAGERCORE_H_
  28
  29 #include <QtCore/QObject>
  30
  31 #include "audioManagerIncludes.h"
  32
  33 /**CONSTANT for the Connection timeout when using asynchronous connect. In mseconds.
  34  *
  35  */
  36 #define CONNECT_TIMEOUT 3000
  37
  38 class HookHandler;
  39 class AudioManagerCore;
  40 class Queue;
  41 class Router;
  42 class Bushandler;
  43 class DBusCommandInterface;
  44
  45 /**
  46  * \class Task
  47  * \brief Base Class for all Tasks
  48  * \details a Base Class for a basic operation together with a set of parameters
  49  * Every Task that can be created by the Hook Plugins is derived from this class
  50  * Be sure to implement executeTask() because this will be called when the task is executed
  51  * Whenever the task is finished, you need to emit the signal signal_nextTask() that will call the next
  52  * Task in the queue.
  53  * \fn virtual void Task::executeTask(Queue* queue)=0
  54  * \brief This needs to be overwritten in implementation of the class
  55  * The queue calls this function to start the execution of the task
  56  * \param queue pointer to the queue
  57  * \fn void Task::signal_nextTask()
  58  * \brief by emitting this signal, the next task in the queue is triggered
  59  */
  60 class Task: public QObject {
  61 Q_OBJECT
  62 public:
  63         Task();
  64         Task(AudioManagerCore* core);
  65         virtual ~Task();
  66         virtual void executeTask(Queue* queue)=0;
  67
  68 signals:
  69         void signal_nextTask();
  70 protected:
  71         AudioManagerCore* m_core; //!< pointer to the core
  72 };
  73
  74 /**
  75  * \class TaskAsyncConnect
  76  * \brief This task is used to connect a source and a sink asynchronous
  77  *
  78  * \fn TaskAsyncConnect::TaskAsyncConnect(AudioManagerCore* core, sink_t sink, source_t source)
  79  * \brief Constructor
  80  * \param core pointer to the core
  81  * \param sink  the sink to be connected
  82  * \param source the source to be connected
  83  *
  84  * \fn void TaskAsyncConnect::setSink(sink_t sink)
  85  * \brief Sets the Sink that should be connected to
  86  * \param sink the sink
  87  *
  88  * \fn void TaskAsyncConnect::setSource(source_t source)
  89  * \brief sets the source
  90  * \param source the source
  91  *
  92  * \fn sink_t TaskAsyncConnect::getSink()
  93  * \brief returns the sink
  94  *
  95  * \fn source_t TaskAsyncConnect::getSource()
  96  * \brief returns the source
  97  *
  98  * \fn void TaskAsyncConnect::slot_connect_finished(genHandle_t handle, genError_t error)
  99  * \brief is used to receive the asynchronous answer.
 100  *
 101  * \fn void TaskAsyncConnect::slot_timeout()
 102  * \brief used to handle the timeout
 103  */
 104 class TaskAsyncConnect: public Task {
 105 Q_OBJECT
 106 public:
 107         TaskAsyncConnect(AudioManagerCore* core, sink_t sink, source_t source);
 108         virtual ~TaskAsyncConnect();
 109         void setSink(sink_t sink);
 110         void setSource(source_t source);
 111         sink_t getSink();
 112         source_t getSource();
 113         void executeTask(Queue* queue);
 114
 115 public slots:
 116         void slot_connect_finished(genHandle_t handle, genError_t error);
 117         void slot_timeout();
 118 private:
 119         sink_t m_ParamSink; //!< the sink to be connected
 120         source_t m_ParamSource; //!< the source to be connected
 121         genHandle_t m_handle; //!< the handle (ConnectionID)
 122         QTimer* m_timer; //!< pointer to a timer used for timeout tracking
 123 };
 124
 125 /**
 126  * \class TaskConnect
 127  * \brief This task is used to connect a source and a sink synchronous
 128  *
 129  * \fn TaskConnect::TaskConnect(AudioManagerCore* core, sink_t sink, source_t source)
 130  * \brief constructor
 131  * \param core pointer to the core
 132  * \param sink  the sink to be connected
 133  * \param source the source to be connected
 134  *
 135  */
 136 class TaskConnect: public Task {
 137 Q_OBJECT
 138 public:
 139         TaskConnect(AudioManagerCore* core, sink_t sink, source_t source);
 140         virtual ~TaskConnect();
 141         void executeTask(Queue* queue);
 142
 143 private:
 144         sink_t m_ParamSink; //!< the sink to be connected
 145         source_t m_ParamSource; //!< the source to be connected
 146 };
 147
 148 /**
 149  * \class TaskDisconnect
 150  * \brief This task is used to connect a source and a sink synchronous
 151  *
 152  * \fn TaskDisconnect::TaskDisconnect(AudioManagerCore* core, connection_t ID)
 153  * \brief constructor
 154  * \param core pointer to the core
 155  * \param ID the connection ID to be disconnected
 156  *
 157  */
 158 class TaskDisconnect: public Task {
 159 Q_OBJECT
 160 public:
 161         TaskDisconnect(AudioManagerCore* core, connection_t ID);
 162         virtual ~TaskDisconnect();
 163         void executeTask(Queue* queue);
 164 private:
 165         connection_t m_ParamConnectionID; //!< the connection to disconnect
 166 };
 167
 168 /**
 169  * \class TaskInterruptWait
 170  * \brief this class waits for an interrupt to be resumed
 171  *
 172  * \fn TaskInterruptWait::TaskInterruptWait(AudioManagerCore* core, genInt_t connectionID)
 173  * \brief Constructor
 174  * \param core link to AudioManagercore
 175  * \param connectionID the connection ID to be waited for
 176  *
 177  * \fn void TaskInterruptWait::slot_interrupt_ready(genInt_t ID)
 178  * \brief slot that is called when the interrupt resumes
 179  * \param ID the interrupt ID of the interrupt that resumed
 180  */
 181 class TaskInterruptWait: public Task {
 182 Q_OBJECT
 183 public:
 184         TaskInterruptWait(AudioManagerCore* core, genInt_t connectionID);
 185         virtual ~TaskInterruptWait();
 186         void executeTask(Queue* queue);
 187 public slots:
 188         void slot_interrupt_ready(genInt_t ID);
 189 private:
 190         genInt_t m_interruptID; //!< the interrupt ID that should be waited for
 191 };
 192
 193 /**
 194  * \class TaskSetVolume
 195  * \brief a task that sets the volume for a sink
 196  *
 197  * \fn TaskSetVolume::TaskSetVolume(AudioManagerCore* core, volume_t newVolume=0, sink_t sink=0)
 198  * \brief constructor
 199  * \param core the pointer to the AudioManagerCore
 200  * \param newVolume the volume to be set
 201  * \param sink the sink that the volume shall be applied to
 202  *
 203  * \fn void TaskSetVolume::setVolume(volume_t newVolume)
 204  * \brief sets the volume
 205  *
 206  * \fn void TaskSetVolume::setSink(sink_t sink)
 207  * \brief sets the sink
 208  *
 209  * \fn volume_t  TaskSetVolume::getVolume()
 210  * \brief returns the volume
 211  *
 212  * \fn sink_t TaskSetVolume::getSink()
 213  * \brief returns the volume
 214  */
 215 class TaskSetVolume: public Task {
 216 Q_OBJECT
 217 public:
 218         TaskSetVolume(AudioManagerCore* core, volume_t newVolume=0, sink_t sink=0);
 219         virtual ~TaskSetVolume();
 220
 221         void setVolume(volume_t newVolume);
 222         void setSink(sink_t sink);
 223
 224         volume_t getVolume();
 225         sink_t getSink();
 226
 227         void executeTask(Queue* queue);
 228 private:
 229         volume_t m_volume; //!< the volume
 230         sink_t m_sink; //!< the sink
 231 };
 232
 233 /**
 234  * \class TaskSetSourceVolume
 235  * \brief sets the volume of a source
 236  *
 237  * \fn TaskSetSourceVolume::TaskSetSourceVolume(AudioManagerCore* core, volume_t newVolume=0, source_t source=0)
 238  * \brief constructor
 239  * \param core the pointer to the AudioManagerCore
 240  * \param newVolume the volumesink_t  to be set
 241  * \param source the source that the volume shall be applied to
 242  *
 243  *  * \fn void TaskSetSourceVolume::setVolume(volume_t newVolume)
 244  * \brief sets the volume
 245  *
 246  * \fn void TaskSetSourceVolume::setSource (source_t source)
 247  * \brief sets the sink
 248  *
 249  * \fn volume_t TaskSetSourceVolume::getVolume()
 250  * \brief returns the volume
 251  */
 252 class TaskSetSourceVolume: public Task {
 253 Q_OBJECT
 254 public:
 255         TaskSetSourceVolume(AudioManagerCore* core, volume_t newVolume=0, source_t source=0);
 256         virtual ~TaskSetSourceVolume();
 257
 258         void setVolume(volume_t newVolume);
 259         void setSource(source_t source);
 260
 261         volume_t getVolume();
 262         source_t getSource();
 263
 264         void executeTask(Queue* queue);
 265 private:
 266         volume_t m_volume; //!< the volume
 267         source_t m_source; //!< the source
 268 };
 269
 270 /**
 271  * \class TaskWait
 272  * \brief implements a wait in msecons
 273  *
 274  * \fn TaskWait::TaskWait(AudioManagerCore* core, int mseconds)
 275  * \brief constructor
 276  * \param core the pointer to the AudioManagerCore
 277  * \param mseconds delay in milliseconds
 278  *
 279  * \fn void TaskWait::setTime(int mseconds)
 280  * \brief sets the time
 281  *
 282  * \fn int TaskWait::getTime()
 283  * \brief returns the time
 284  *
 285  * \fn  void TaskWait::slot_timeIsup()
 286  * \brief slot called when the time is up
 287  */
 288 class TaskWait: public Task {
 289 Q_OBJECT
 290 public:
 291         TaskWait(AudioManagerCore* core, int mseconds);
 292         virtual ~TaskWait();
 293         void setTime(int mseconds);
 294         int getTime();
 295         void executeTask(Queue* queue);
 296
 297 public slots:
 298         void slot_timeIsup();
 299 private:
 300         int m_ParamMSeconds;//!< time to be delayed in milli seconds
 301         QTimer* m_timer; //!< pointer to timer
 302 };
 303
 304 /**
 305  * \class TaskEnterUserConnect
 306  * \brief This task enters the user connection into the struct of the AudioManagerCore
 307  * \details We need this because the connection shall be entered not before it is build up
 308  *
 309  * \fn TaskEnterUserConnect::TaskEnterUserConnect(AudioManagerCore* core, genRoute_t route, connection_t connID=0)
 310  * \brief enters a user connect into the database
 311  */
 312 class TaskEnterUserConnect: public Task {
 313 Q_OBJECT
 314 public:
 315         TaskEnterUserConnect(AudioManagerCore* core, genRoute_t route, connection_t connID=0);
 316         virtual ~TaskEnterUserConnect();
 317         void setConnection(genRoute_t route, connection_t connID);
 318         genRoute_t returnConnection();
 319         void executeTask(Queue* queue);
 320 private:
 321         genRoute_t m_route;             //!< the route to be entered
 322         connection_t m_connectionID; //!< the connection ID
 323 };
 324
 325 /**
 326  * \class TaskRemoveUserConnect
 327  * \brief removes a user Connect
 328  *
 329  * \fn TaskRemoveUserConnect::TaskRemoveUserConnect(AudioManagerCore* core, connection_t connID)
 330  * \brief constructor
 331  */
 332 class TaskRemoveUserConnect : public Task {
 333 Q_OBJECT
 334 public:
 335         TaskRemoveUserConnect(AudioManagerCore* core, connection_t connID);
 336         virtual ~TaskRemoveUserConnect();
 337         void setConnectionID(connection_t connID);
 338         connection_t returnConnectionID();
 339         void executeTask(Queue* queue);
 340 private:
 341         connection_t m_connectionID; //!< the connection ID
 342 };
 343
 344 /**
 345  * \class TaskEnterInterrupt
 346  * \brief enters an interrupt into the database
 347  */
 348 class TaskEnterInterrupt: public Task {
 349 Q_OBJECT
 350 public:
 351         TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,bool mixed, connection_t connID, QList<source_t> listInterruptedSources);
 352         virtual ~TaskEnterInterrupt();
 353         void executeTask(Queue* queue);
 354 private:
 355         genInt_t m_intID; //!< the interrupt ID
 356         bool m_mixed; //!< true if mixed
 357         connection_t m_connectionID; //!< the connection ID
 358         QList<source_t> m_interruptedSourcesList; //!< the list of interrupted sources
 359 };
 360
 361 /**
 362  * \class TaskRemoveInterrupt
 363  * \brief removes an interrupt
 364  */
 365 class TaskRemoveInterrupt: public Task {
 366 Q_OBJECT
 367 public:
 368         TaskRemoveInterrupt(AudioManagerCore* core, genInt_t ID);
 369         virtual ~TaskRemoveInterrupt();
 370         void executeTask(Queue* queue);
 371 private:
 372         genInt_t m_intID; //!< the interrupt ID
 373 };
 374
 375 /**
 376  * \class TaskSetSourceMute
 377  * \brief mutes a source
 378  */
 379 class TaskSetSourceMute: public Task {
 380 Q_OBJECT
 381 public:
 382         TaskSetSourceMute(AudioManagerCore* core, source_t source);
 383         virtual ~TaskSetSourceMute();
 384         void executeTask(Queue* queue);
 385 private:
 386         source_t m_source; //!< the source to be muted
 387 };
 388
 389 /**
 390  * \class TaskSetSourceUnmute
 391  * \brief unmutes a source
 392  */
 393 class TaskSetSourceUnmute: public Task {
 394 Q_OBJECT
 395 public:
 396         TaskSetSourceUnmute(AudioManagerCore* core, source_t source);
 397         virtual ~TaskSetSourceUnmute();
 398         void executeTask(Queue* queue);
 399 private:
 400         source_t m_source; //!< the source to be unmuted
 401 };
 402
 403 /**
 404  * \class TaskEmitSignalConnect
 405  * \brief emits the signal connect
 406  */
 407 class TaskEmitSignalConnect: public Task {
 408 Q_OBJECT
 409 public:
 410         TaskEmitSignalConnect(AudioManagerCore* core);
 411         virtual ~TaskEmitSignalConnect();
 412         void executeTask(Queue* queue);
 413 };
 414
 415 /**
 416  * \class Queue
 417  * \brief With the help of this class, all events that need to be processed are organized and queued
 418  * \details tasks to be added have to be created with new, after the queue is done all tasks will be deleted and the memory freed.
 419  * \todo error handling
 420  * \todo sorting of tasks
 421  * \todo add some function to attach parameters to the Queue so that organizing and handling is possible
 422  *
 423  * \fn Queue::Queue(AudioManagerCore* core,QString name="")
 424  * \brief constructor
 425  * \param name give the queue a name
 426  * \param core pointer to AudioManagerCore
 427  *
 428  * \fn void Queue::run()
 429  * \brief starts the queue
 430  *
 431  * \fn void Queue::addTask(Task* task)
 432  * \brief add a task to the queue
 433  * \param task pointer to the task
 434  *
 435  * \fn genError_t Queue::removeTask(Task* task)
 436  * \brief removes a task
 437  * \param task pointer to the task
 438  * \return GEN_OK on success
 439  *
 440  * \fn  QList<Task*> Queue::getTaskList()
 441  * \brief returns the actual task list
 442  * \return list with pointers to the tasks
 443  *
 444  * \fn QString Queue::returnName()
 445  * \brief returns the name of the Queue
 446  * \return the name in QString format
 447  *
 448  * \fn void Queue::slot_nextTask()
 449  * \brief is called when a task is finished and the next task can be called
 450  */
 451 class Queue: public QObject {
 452 Q_OBJECT
 453 public:
 454         Queue(AudioManagerCore* core,QString name="");
 455         virtual ~Queue();
 456         void run();
 457         void addTask(Task* task);
 458         genError_t removeTask(Task* task);
 459         QList<Task*> getTaskList();
 460         QString returnName();
 461
 462 public slots:
 463         void slot_nextTask();
 464 private:
 465         AudioManagerCore* m_core; //!< pointer to AudioManagerCore
 466         int m_currentIndex; //!< the index of the list wich is currently worked on
 467         QString m_name; //!< name of the Queue
 468         QList<Task*> m_taskList; //!< the list with pointers to the tasks
 469 };
 470
 471 /**
 472  * \class AudioManagerCore
 473  * \brief The central Managing Class of the AudioManager
 474  *
 475  * \fn genError_t AudioManagerCore::UserConnect(source_t source, sink_t sink)
 476  * \brief does a user connect
 477  *
 478  * \fn genError_t AudioManagerCore::UserDisconnect(connection_t connID)
 479  * \brief does a user disconnect
 480  *
 481  * \fn genError_t AudioManagerCore::UserSetVolume(sink_t sink, volume_t volume)
 482  * \brief set the user volume (on sink level)
 483  *
 484  * \fn genError_t AudioManagerCore::connect(source_t source, sink_t sink, genHandle_t* handle = NULL)
 485  * \brief connects sources and sinks
 486  *
 487  * \fn genError_t AudioManagerCore::disconnect(connection_t ID)
 488  * \brief disconnects sources and sinks
 489  *
 490  * \fn genError_t AudioManagerCore::setVolume(sink_t sink, volume_t volume)
 491  * \brief sets the volume to a sink
 492  *
 493  * \fn genError_t AudioManagerCore::interruptRequest(source_t interruptSource, sink_t sink, genInt_t* interruptID)
 494  * \brief via this call, an interrupt is requested
 495  *
 496  * \fn genError_t AudioManagerCore::setSourceVolume (source_t source, volume_t volume)
 497  * \brief sets the source volume
 498  *
 499  * \fn genError_t AudioManagerCore::setSourceMute (source_t source)
 500  * \brief mutes a source
 501  *
 502  * \fn genError_t AudioManagerCore::setSourceUnMute (source_t source)
 503  * \brief unmutes a source
 504  *
 505  * \fn genError_t AudioManagerCore::getRoute(const bool onlyfree, const source_t source, const sink_t sink, QList<genRoute_t>* ReturnList)
 506  * \brief returns a route
 507  *
 508  * \fn connection_t AudioManagerCore::returnConnectionIDforSinkSource (sink_t sink, source_t source)
 509  * \brief returns the connection ID for a sink source combination
 510  *
 511  * \fn source_t AudioManagerCore::returnSourceIDfromName(const QString name)
 512  * \brief returns the source ID for a name
 513  *
 514  * \fn sink_t AudioManagerCore::returnSinkIDfromName(const QString name)
 515  * \brief returns the sink ID for a given name
 516  *
 517  * \fn QList<ConnectionType> AudioManagerCore::getListConnections()
 518  * \brief returns the list of connections
 519  *
 520  * \fn QList<SinkType> AudioManagerCore::getListSinks()
 521  * \brief returns a list of all sinks
 522  *
 523  * \fn QList<SourceType> AudioManagerCore::getListSources()
 524  * \brief returns a list of all sources
 525  *
 526  * \fn void AudioManagerCore::emitSignalConnect()
 527  * \brief emits the signal connect
 528  *
 529  * \fn Router* AudioManagerCore::returnRouter()
 530  * \brief returns the pointer to the router
 531  *
 532  * \fn DataBaseHandler* AudioManagerCore::returnDatabaseHandler()
 533  * \brief returns the pointer to the database handler
 534  *
 535  * \fn RoutingReceiver* AudioManagerCore::returnReceiver()
 536  * \brief returns the pointer to the receiver
 537  *
 538  * \fn DBusCommandInterface* AudioManagerCore::returnCommandInterface()
 539  * \brief returns the pointer to the command interface
 540  *
 541  * \fn void AudioManagerCore::registerDatabasehandler(DataBaseHandler * handler)
 542  * \brief registers the database handler @ the core
 543  *
 544  * \fn void AudioManagerCore::registerRouter(Router* router)
 545  * \brief registers the router @ the core
 546  *
 547  * \fn void AudioManagerCore::registerBushandler(Bushandler* handler)
 548  * \brief registers the bushandler @ the core
 549  *
 550  * \fn void AudioManagerCore::registerHookEngine(HookHandler* handler)
 551  * \brief registers the hook engine @ the core
 552  *
 553  * \fn void AudioManagerCore::registerReceiver(RoutingReceiver* receiver)
 554  * \brief registers the receiver @ the core
 555  *
 556  * \fn void AudioManagerCore::registerCommandInterface(DBusCommandInterface* command)
 557  * \brief registers the command interface @ the core
 558  *
 559  * \fn void AudioManagerCore::addQueue(Queue* queue)
 560  * \brief adds a queue
 561  *
 562  * \fn genError_t AudioManagerCore::removeQueue(Queue* queue)
 563  * \brief removes a queue
 564  *
 565  *
 566  */
 567 class AudioManagerCore :public QObject {
 568 Q_OBJECT
 569 public:
 570         AudioManagerCore();
 571         virtual ~AudioManagerCore();
 572
 573         genError_t UserConnect(source_t source, sink_t sink);
 574         genError_t UserDisconnect(connection_t connID);
 575         genError_t UserSetVolume(sink_t sink, volume_t volume);
 576         genError_t connect(source_t source, sink_t sink, genHandle_t* handle = NULL);
 577         genError_t disconnect(connection_t ID);
 578         genError_t setVolume(sink_t sink, volume_t volume);
 579         genError_t interruptRequest(source_t interruptSource, sink_t sink, genInt_t* interruptID);
 580         genError_t setSourceVolume (source_t source, volume_t volume);
 581         genError_t setSourceMute (source_t source);
 582         genError_t setSourceUnMute (source_t source);
 583
 584         genError_t getRoute(const bool onlyfree, const source_t source, const sink_t sink, QList<genRoute_t>* ReturnList);
 585         connection_t returnConnectionIDforSinkSource (sink_t sink, source_t source);
 586         source_t returnSourceIDfromName(const QString name);
 587         sink_t returnSinkIDfromName(const QString name);
 588
 589         QList<ConnectionType> getListConnections();
 590         QList<SinkType> getListSinks();
 591         QList<SourceType> getListSources();
 592
 593         void emitSignalConnect();
 594
 595         Router* returnRouter();
 596         DataBaseHandler* returnDatabaseHandler();
 597         RoutingReceiver* returnReceiver();
 598         DBusCommandInterface* returnCommandInterface();
 599
 600         void registerDatabasehandler(DataBaseHandler * handler);
 601         void registerRouter(Router* router);
 602         void registerBushandler(Bushandler* handler);
 603         void registerHookEngine(HookHandler* handler);
 604         void registerReceiver(RoutingReceiver* receiver);
 605         void registerCommandInterface(DBusCommandInterface* command);
 606
 607         void addQueue(Queue* queue);
 608         genError_t removeQueue(Queue* queue);
 609
 610 signals:
 611         void signal_connectionChanged();
 612         void signal_numberOfSinksChanged();
 613         void signal_numberOfSourcesChanged();
 614
 615 private:
 616         DataBaseHandler* m_databaseHandler; //!< pointer to the DataBasehandler Class
 617         Router* m_router; //!< pointer to the Router Class
 618         Bushandler* m_busHandler; //!< pointer to the Bushandler Class
 619         HookHandler* m_hookHandler; //!< pointer to the HookHandler CLass
 620         RoutingReceiver* m_receiver; //!< pointer to the Routing receiver Class
 621         DBusCommandInterface* m_command; //!< pointer to the command Interface Class
 622
 623         QList<Queue*> m_queueList; //!< List of pointers to all running queues
 624 };
 625
 626 #endif /* AUDIOMANAGERCORE_H_ */