2 * Copyright (C) 2011, BMW AG
6 * \file AudioManagerCore.h
9 * \author Christian Müller (christian.ei.mueller@bmw.de)
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
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.
26 #ifndef AUDIOMANAGERCORE_H_
27 #define AUDIOMANAGERCORE_H_
30 #include "audioManagerIncludes.h"
32 /**CONSTANT for the Connection timeout when using asynchronous connect. In mseconds.
35 #define CONNECT_TIMEOUT 3000
38 class AudioManagerCore;
42 class DBusCommandInterface;
46 * \brief Base Class for all Tasks
47 * \details a Base Class for a basic operation together with a set of parameters
48 * Every Task that can be created by the Hook Plugins is derived from this class
49 * Be sure to implement executeTask() because this will be called when the task is executed
50 * Whenever the task is finished, you need to emit the signal signal_nextTask() that will call the next
52 * \fn virtual void Task::executeTask(Queue* queue)=0
53 * \brief This needs to be overwritten in implementation of the class
54 * The queue calls this function to start the execution of the task
55 * \param queue pointer to the queue
56 * \fn void Task::signal_nextTask()
57 * \brief by emitting this signal, the next task in the queue is triggered
62 Task(AudioManagerCore* core);
64 virtual void executeTask(Queue* queue)=0;
66 void signal_nextTask();
68 AudioManagerCore* m_core; //!< pointer to the core
72 * \class TaskAsyncConnect
73 * \brief This task is used to connect a source and a sink asynchronous
75 * \fn TaskAsyncConnect::TaskAsyncConnect(AudioManagerCore* core, sink_t sink, source_t source)
77 * \param core pointer to the core
78 * \param sink the sink to be connected
79 * \param source the source to be connected
81 * \fn void TaskAsyncConnect::setSink(sink_t sink)
82 * \brief Sets the Sink that should be connected to
83 * \param sink the sink
85 * \fn void TaskAsyncConnect::setSource(source_t source)
86 * \brief sets the source
87 * \param source the source
89 * \fn sink_t TaskAsyncConnect::getSink()
90 * \brief returns the sink
92 * \fn source_t TaskAsyncConnect::getSource()
93 * \brief returns the source
95 * \fn void TaskAsyncConnect::slot_connect_finished(genHandle_t handle, genError_t error)
96 * \brief is used to receive the asynchronous answer.
98 * \fn void TaskAsyncConnect::slot_timeout()
99 * \brief used to handle the timeout
101 class TaskAsyncConnect: public Task {
104 TaskAsyncConnect(AudioManagerCore* core, sink_t sink, source_t source);
105 virtual ~TaskAsyncConnect();
106 void setSink(sink_t sink);
107 void setSource(source_t source);
109 source_t getSource();
110 void executeTask(Queue* queue);
112 void slot_connect_finished(genHandle_t handle, genError_t error);
115 sink_t m_ParamSink; //!< the sink to be connected
116 source_t m_ParamSource; //!< the source to be connected
117 genHandle_t m_handle; //!< the handle (ConnectionID)
118 //QTimer* m_timer; //!< pointer to a timer used for timeout tracking
120 * \todo implement non QT Timer
126 * \brief This task is used to connect a source and a sink synchronous
128 * \fn TaskConnect::TaskConnect(AudioManagerCore* core, sink_t sink, source_t source)
130 * \param core pointer to the core
131 * \param sink the sink to be connected
132 * \param source the source to be connected
135 class TaskConnect: public Task {
138 TaskConnect(AudioManagerCore* core, sink_t sink, source_t source);
139 virtual ~TaskConnect();
140 void executeTask(Queue* queue);
143 sink_t m_ParamSink; //!< the sink to be connected
144 source_t m_ParamSource; //!< the source to be connected
148 * \class TaskDisconnect
149 * \brief This task is used to connect a source and a sink synchronous
151 * \fn TaskDisconnect::TaskDisconnect(AudioManagerCore* core, connection_t ID)
153 * \param core pointer to the core
154 * \param ID the connection ID to be disconnected
157 class TaskDisconnect: public Task {
160 TaskDisconnect(AudioManagerCore* core, connection_t ID);
161 virtual ~TaskDisconnect();
162 void executeTask(Queue* queue);
164 connection_t m_ParamConnectionID; //!< the connection to disconnect
168 * \class TaskInterruptWait
169 * \brief this class waits for an interrupt to be resumed
171 * \fn TaskInterruptWait::TaskInterruptWait(AudioManagerCore* core, genInt_t connectionID)
173 * \param core link to AudioManagercore
174 * \param connectionID the connection ID to be waited for
176 * \fn void TaskInterruptWait::slot_interrupt_ready(genInt_t ID)
177 * \brief slot that is called when the interrupt resumes
178 * \param ID the interrupt ID of the interrupt that resumed
180 class TaskInterruptWait: public Task {
183 TaskInterruptWait(AudioManagerCore* core, genInt_t connectionID);
184 virtual ~TaskInterruptWait();
185 void executeTask(Queue* queue);
187 void slot_interrupt_ready(genInt_t ID);
189 genInt_t m_interruptID; //!< the interrupt ID that should be waited for
193 * \class TaskSetVolume
194 * \brief a task that sets the volume for a sink
196 * \fn TaskSetVolume::TaskSetVolume(AudioManagerCore* core, volume_t newVolume=0, sink_t sink=0)
198 * \param core the pointer to the AudioManagerCore
199 * \param newVolume the volume to be set
200 * \param sink the sink that the volume shall be applied to
202 * \fn void TaskSetVolume::setVolume(volume_t newVolume)
203 * \brief sets the volume
205 * \fn void TaskSetVolume::setSink(sink_t sink)
206 * \brief sets the sink
208 * \fn volume_t TaskSetVolume::getVolume()
209 * \brief returns the volume
211 * \fn sink_t TaskSetVolume::getSink()
212 * \brief returns the volume
214 class TaskSetVolume: public Task {
217 TaskSetVolume(AudioManagerCore* core, volume_t newVolume=0, sink_t sink=0);
218 virtual ~TaskSetVolume();
220 void setVolume(volume_t newVolume);
221 void setSink(sink_t sink);
223 volume_t getVolume();
226 void executeTask(Queue* queue);
228 volume_t m_volume; //!< the volume
229 sink_t m_sink; //!< the sink
233 * \class TaskSetSourceVolume
234 * \brief sets the volume of a source
236 * \fn TaskSetSourceVolume::TaskSetSourceVolume(AudioManagerCore* core, volume_t newVolume=0, source_t source=0)
238 * \param core the pointer to the AudioManagerCore
239 * \param newVolume the volumesink_t to be set
240 * \param source the source that the volume shall be applied to
242 * * \fn void TaskSetSourceVolume::setVolume(volume_t newVolume)
243 * \brief sets the volume
245 * \fn void TaskSetSourceVolume::setSource (source_t source)
246 * \brief sets the sink
248 * \fn volume_t TaskSetSourceVolume::getVolume()
249 * \brief returns the volume
251 class TaskSetSourceVolume: public Task {
254 TaskSetSourceVolume(AudioManagerCore* core, volume_t newVolume=0, source_t source=0);
255 virtual ~TaskSetSourceVolume();
257 void setVolume(volume_t newVolume);
258 void setSource(source_t source);
260 volume_t getVolume();
261 source_t getSource();
263 void executeTask(Queue* queue);
265 volume_t m_volume; //!< the volume
266 source_t m_source; //!< the source
271 * \brief implements a wait in msecons
273 * \fn TaskWait::TaskWait(AudioManagerCore* core, int mseconds)
275 * \param core the pointer to the AudioManagerCore
276 * \param mseconds delay in milliseconds
278 * \fn void TaskWait::setTime(int mseconds)
279 * \brief sets the time
281 * \fn int TaskWait::getTime()
282 * \brief returns the time
284 * \fn void TaskWait::slot_timeIsup()
285 * \brief slot called when the time is up
287 class TaskWait: public Task {
290 TaskWait(AudioManagerCore* core, int mseconds);
292 void setTime(int mseconds);
294 void executeTask(Queue* queue);
295 void slot_timeIsup();
297 int m_ParamMSeconds;//!< time to be delayed in milli seconds
298 // QTimer* m_timer; //!< pointer to timer
300 *\todo replace Qtimer
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
309 * \fn TaskEnterUserConnect::TaskEnterUserConnect(AudioManagerCore* core, genRoute_t route, connection_t connID=0)
310 * \brief enters a user connect into the database
312 class TaskEnterUserConnect: public Task {
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);
321 genRoute_t m_route; //!< the route to be entered
322 connection_t m_connectionID; //!< the connection ID
326 * \class TaskRemoveUserConnect
327 * \brief removes a user Connect
329 * \fn TaskRemoveUserConnect::TaskRemoveUserConnect(AudioManagerCore* core, connection_t connID)
332 class TaskRemoveUserConnect : public Task {
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);
341 connection_t m_connectionID; //!< the connection ID
345 * \class TaskEnterInterrupt
346 * \brief enters an interrupt into the database
348 class TaskEnterInterrupt: public Task {
351 TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,bool mixed, connection_t connID, std::list<source_t> listInterruptedSources);
352 virtual ~TaskEnterInterrupt();
353 void executeTask(Queue* queue);
355 genInt_t m_intID; //!< the interrupt ID
356 bool m_mixed; //!< true if mixed
357 connection_t m_connectionID; //!< the connection ID
358 std::list<source_t> m_interruptedSourcesList; //!< the list of interrupted sources
362 * \class TaskRemoveInterrupt
363 * \brief removes an interrupt
365 class TaskRemoveInterrupt: public Task {
368 TaskRemoveInterrupt(AudioManagerCore* core, genInt_t ID);
369 virtual ~TaskRemoveInterrupt();
370 void executeTask(Queue* queue);
372 genInt_t m_intID; //!< the interrupt ID
376 * \class TaskSetSourceMute
377 * \brief mutes a source
379 class TaskSetSourceMute: public Task {
382 TaskSetSourceMute(AudioManagerCore* core, source_t source);
383 virtual ~TaskSetSourceMute();
384 void executeTask(Queue* queue);
386 source_t m_source; //!< the source to be muted
390 * \class TaskSetSourceUnmute
391 * \brief unmutes a source
393 class TaskSetSourceUnmute: public Task {
396 TaskSetSourceUnmute(AudioManagerCore* core, source_t source);
397 virtual ~TaskSetSourceUnmute();
398 void executeTask(Queue* queue);
400 source_t m_source; //!< the source to be unmuted
404 * \class TaskEmitSignalConnect
405 * \brief emits the signal connect
407 class TaskEmitSignalConnect: public Task {
409 TaskEmitSignalConnect(AudioManagerCore* core);
410 virtual ~TaskEmitSignalConnect();
411 void executeTask(Queue* queue);
416 * \brief With the help of this class, all events that need to be processed are organized and queued
417 * \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.
418 * \todo error handling
419 * \todo sorting of tasks
420 * \todo add some function to attach parameters to the Queue so that organizing and handling is possible
422 * \fn Queue::Queue(AudioManagerCore* core,std::string name="")
424 * \param name give the queue a name
425 * \param core pointer to AudioManagerCore
427 * \fn void Queue::run()
428 * \brief starts the queue
430 * \fn void Queue::addTask(Task* task)
431 * \brief add a task to the queue
432 * \param task pointer to the task
434 * \fn genError_t Queue::removeTask(Task* task)
435 * \brief removes a task
436 * \param task pointer to the task
437 * \return GEN_OK on success
439 * \fn std::list<Task*> Queue::getTaskList()
440 * \brief returns the actual task list
441 * \return list with pointers to the tasks
443 * \fn std::string Queue::returnName()
444 * \brief returns the name of the Queue
445 * \return the name in std::string format
447 * \fn void Queue::slot_nextTask()
448 * \brief is called when a task is finished and the next task can be called
453 Queue(AudioManagerCore* core,std::string name="");
456 void addTask(Task* task);
457 genError_t removeTask(Task* task);
458 std::list<Task*> getTaskList();
459 std::string returnName();
461 void slot_nextTask();
463 AudioManagerCore* m_core; //!< pointer to AudioManagerCore
464 std::list<Task*>::iterator m_currentIndex; //!< the index of the list wich is currently worked on
465 std::string m_name; //!< name of the Queue
466 std::list<Task*> m_taskList; //!< the list with pointers to the tasks
469 /**:3: error: ISO C++ forbids declaration of ‘type name’ with no type
471 * \class AudioManagerCore
472 * \brief The central Managing Class of the AudioManager
474 * \fn genError_t AudioManagerCore::UserConnect(source_t source, sink_t sink)
475 * \brief does a user connect
477 * \fn genError_t AudioManagerCore::UserDisconnect(connection_t connID)
478 * \brief does a user disconnect
480 * \fn genError_t AudioManagerCore::UserSetVolume(sink_t sink, volume_t volume)
481 * \brief set the user volume (on sink level)
483 * \fn genError_t AudioManagerCore::connect(source_t source, sink_t sink, genHandle_t* handle = NULL)
484 * \brief connects sources and sinks
486 * \fn genError_t AudioManagerCore::disconnect(connection_t ID)
487 * \brief disconnects sources and sinks
489 * \fn genError_t AudioManagerCore::setVolume(sink_t sink, volume_t volume)
490 * \brief sets the volume to a sink
492 * \fn genError_t AudioManagerCore::interruptRequest(source_t interruptSource, sink_t sink, genInt_t* interruptID)
493 * \brief via this call, an interrupt is requested
495 * \fn genError_t AudioManagerCore::setSourceVolume (source_t source, volume_t volume)
496 * \brief sets the source volume
498 * \fn genError_t AudioManagerCore::setSourceMute (source_t source)
499 * \brief mutes a source
501 * \fn genError_t AudioManagerCore::setSourceUnMute (source_t source)
502 * \brief unmutes a source
504 * \fn genError_t AudioManagerCore::getRoute(const bool onlyfree, const source_t source, const sink_t sink, std::list<genRoute_t>* ReturnList)
505 * \brief returns a route
507 * \fn connection_t AudioManagerCore::returnConnectionIDforSinkSource (sink_t sink, source_t source)
508 * \brief returns the connection ID for a sink source combination
510 * \fn source_t AudioManagerCore::returnSourceIDfromName(const std::string name)
511 * \brief returns the source ID for a name
513 * \fn sink_t AudioManagerCore::returnSinkIDfromName(const std::string name)
514 * \brief returns the sink ID for a given name
516 * \fn std::list<ConnectionType> AudioManagerCore::getListConnections()
517 * \brief returns the list of connections
519 * \fn std::list<SinkType> AudioManagerCore::getListSinks()
520 * \brief returns a list of all sinks
522 * \fn std::list<SourceType> AudioManagerCore::getListSources()
523 * \brief returns a list of all sources
525 * \fn void AudioManagerCore::emitSignalConnect()
526 * \brief emits the signal connect
528 * \fn Router* AudioManagerCore::returnRouter()
529 * \brief returns the pointer to the router
531 * \fn DataBaseHandler* AudioManagerCore::returnDatabaseHandler()
532 * \brief returns the pointer to the database handler
534 * \fn RoutingReceiver* AudioManagerCore::returnReceiver()
535 * \brief returns the pointer to the receiver
537 * \fn DBusCommandInterface* AudioManagerCore::returnCommandInterface()
538 * \brief returns the pointer to the command interface
540 * \fn void AudioManagerCore::registerDatabasehandler(DataBaseHandler * handler)
541 * \brief registers the database handler @ the core
543 * \fn void AudioManagerCore::registerRouter(Router* router)
544 * \brief registers the router @ the core
546 * \fn void AudioManagerCore::registerBushandler(Bushandler* handler)
547 * \brief registers the bushandler @ the core
549 * \fn void AudioManagerCore::registerHookEngine(HookHandler* handler)
550 * \brief registers the hook engine @ the core
552 * \fn void AudioManagerCore::registerReceiver(RoutingReceiver* receiver)
553 * \brief registers the receiver @ the core
555 * \fn void AudioManagerCore::registerCommandInterface(DBusCommandInterface* command)
556 * \brief registers the command interface @ the core
558 * \fn void AudioManagerCore::addQueue(Queue* queue)
559 * \brief adds a queue
561 * \fn genError_t AudioManagerCore::removeQueue(Queue* queue)
562 * \brief removes a queue
566 class AudioManagerCore {
570 virtual ~AudioManagerCore();
572 genError_t UserConnect(source_t source, sink_t sink);
573 genError_t UserDisconnect(connection_t connID);
574 genError_t UserSetVolume(sink_t sink, volume_t volume);
575 genError_t connect(source_t source, sink_t sink, genHandle_t* handle = NULL);
576 genError_t disconnect(connection_t ID);
577 genError_t setVolume(sink_t sink, volume_t volume);
578 genError_t interruptRequest(source_t interruptSource, sink_t sink, genInt_t* interruptID);
579 genError_t setSourceVolume (source_t source, volume_t volume);
580 genError_t setSourceMute (source_t source);
581 genError_t setSourceUnMute (source_t source);
583 genError_t getRoute(const bool onlyfree, const source_t source, const sink_t sink, std::list<genRoute_t>* ReturnList);
584 connection_t returnConnectionIDforSinkSource (sink_t sink, source_t source);
585 source_t returnSourceIDfromName(const std::string name);
586 sink_t returnSinkIDfromName(const std::string name);
588 std::list<ConnectionType> getListConnections();
589 std::list<SinkType> getListSinks();
590 std::list<SourceType> getListSources();
592 void emitSignalConnect();
594 Router* returnRouter();
595 DataBaseHandler* returnDatabaseHandler();
596 RoutingReceiver* returnReceiver();
597 DBusCommandInterface* returnCommandInterface();
599 void registerDatabasehandler(DataBaseHandler * handler);
600 void registerRouter(Router* router);
601 void registerBushandler(Bushandler* handler);
602 void registerHookEngine(HookHandler* handler);
603 void registerReceiver(RoutingReceiver* receiver);
604 void registerCommandInterface(DBusCommandInterface* command);
606 void addQueue(Queue* queue);
607 genError_t removeQueue(Queue* queue);
609 void signal_connectionChanged();
610 void signal_numberOfSinksChanged();
611 void signal_numberOfSourcesChanged();
614 DataBaseHandler* m_databaseHandler; //!< pointer to the DataBasehandler Class
615 Router* m_router; //!< pointer to the Router Class
616 Bushandler* m_busHandler; //!< pointer to the Bushandler Class
617 HookHandler* m_hookHandler; //!< pointer to the HookHandler CLass
618 RoutingReceiver* m_receiver; //!< pointer to the Routing receiver Class
619 DBusCommandInterface* m_command; //!< pointer to the command Interface Class
621 std::list<Queue*> m_queueList; //!< List of pointers to all running queues
624 #endif /* AUDIOMANAGERCORE_H_ */