2 * Copyright (C) 2011, BMW AG
4 * GeniviAudioMananger AudioManagerDaemon
6 * \file ControlReceiver.cpp
8 * \date 20-Oct-2011 3:42:04 PM
9 * \author Christian Mueller (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 Mueller 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 #include <SocketHandler.h>
27 #include "ControlReceiver.h"
28 #include "DatabaseHandler.h"
29 #include "RoutingSender.h"
30 #include "CommandSender.h"
34 DLT_IMPORT_CONTEXT(AudioManager)
38 ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender, SocketHandler *iSocketHandler) :
39 mDatabaseHandler(iDatabaseHandler), //
40 mRoutingSender(iRoutingSender), //
41 mCommandSender(iCommandSender), //
42 mSocketHandler(iSocketHandler)
44 assert(mDatabaseHandler!=NULL);
45 assert(mRoutingSender!=NULL);
46 assert(mCommandSender!=NULL);
47 assert(mSocketHandler!=NULL);
50 ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender) :
51 mDatabaseHandler(iDatabaseHandler), //
52 mRoutingSender(iRoutingSender), //
53 mCommandSender(iCommandSender)
55 assert(mDatabaseHandler!=NULL);
56 assert(mRoutingSender!=NULL);
57 assert(mCommandSender!=NULL);
60 ControlReceiver::~ControlReceiver()
64 am_Error_e ControlReceiver::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & returnList)
66 //todo: implement routing algorithm
70 am_Error_e ControlReceiver::connect(am_Handle_s & handle, am_connectionID_t & connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID)
72 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::connect got called, connectionFormat"), DLT_INT(format), DLT_STRING("sourceID"), DLT_INT(sourceID), DLT_STRING("sinkID"), DLT_INT(sinkID));
74 am_Connection_s tempConnection;
75 tempConnection.sinkID = sinkID;
76 tempConnection.sourceID = sourceID;
77 tempConnection.connectionFormat = format;
78 tempConnection.connectionID = 0;
80 //todo: enter function to find out what happends if the same connection is in the course of being build up.
81 if (mDatabaseHandler->existConnection(tempConnection)) return E_ALREADY_EXISTS; //todo:enter the correct connectionID here?
83 mDatabaseHandler->enterConnectionDB(tempConnection, connectionID);
84 return mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format);
87 am_Error_e ControlReceiver::disconnect(am_Handle_s & handle, const am_connectionID_t connectionID)
89 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::disconnect got called, connectionID="), DLT_INT(connectionID));
91 if (!mDatabaseHandler->existConnectionID(connectionID)) return E_NON_EXISTENT; //todo: check with EA model and correct
92 return mRoutingSender->asyncDisconnect(handle, connectionID);
95 am_Error_e ControlReceiver::crossfade(am_Handle_s & handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_RampType_e rampType, const am_time_t rampTime)
97 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::crossfade got called, hotSource="), DLT_INT(hotSource), DLT_STRING("crossfaderID="), DLT_INT(crossfaderID), DLT_STRING("rampType="), DLT_INT(rampType), DLT_STRING("rampTime="), DLT_INT(rampTime));
99 if (!mDatabaseHandler->existcrossFader(crossfaderID)) return E_NON_EXISTENT;
100 return mRoutingSender->asyncCrossFade(handle, crossfaderID, hotSource, rampType, rampTime);
103 am_Error_e ControlReceiver::setSourceState(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SourceState_e state)
105 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceState got called, sourceID="), DLT_INT(sourceID), DLT_STRING("state="), DLT_INT(state));
107 am_SourceState_e sourceState;
108 if (mDatabaseHandler->getSoureState(sourceID, sourceState) != E_OK) return E_UNKNOWN;
109 if (sourceState == state) return E_NO_CHANGE;
110 return mRoutingSender->asyncSetSourceState(handle, sourceID, state);
113 am_Error_e ControlReceiver::setSinkVolume(am_Handle_s & handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time)
115 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSinkVolume got called, sinkID="), DLT_INT(sinkID), DLT_STRING("volume="), DLT_INT(volume), DLT_STRING("ramp="), DLT_INT(ramp), DLT_STRING("time="), DLT_INT(time));
117 am_volume_t tempVolume;
118 if (mDatabaseHandler->getSinkVolume(sinkID, tempVolume) != E_OK) return E_UNKNOWN;
119 if (tempVolume == volume) return E_NO_CHANGE;
120 return mRoutingSender->asyncSetSinkVolume(handle, sinkID, volume, ramp, time);
123 am_Error_e ControlReceiver::setSourceVolume(am_Handle_s & handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e rampType, const am_time_t time)
125 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceVolume got called, sourceID="), DLT_INT(sourceID), DLT_STRING("volume="), DLT_INT(volume), DLT_STRING("ramp="), DLT_INT(rampType), DLT_STRING("time="), DLT_INT(time));
127 am_volume_t tempVolume;
128 if (mDatabaseHandler->getSourceVolume(sourceID, tempVolume) != E_OK) return E_UNKNOWN;
129 if (tempVolume == volume) return E_NO_CHANGE;
130 return mRoutingSender->asyncSetSourceVolume(handle, sourceID, volume, rampType, time);
133 am_Error_e ControlReceiver::setSinkSoundProperty(am_Handle_s & handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty)
135 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSinkSoundProperty got called, sinkID="), DLT_INT(sinkID), DLT_STRING("soundProperty.Type="), DLT_INT(soundProperty.type), DLT_STRING("soundProperty.value="), DLT_INT(soundProperty.value));
138 if (mDatabaseHandler->getSinkSoundPropertyValue(sinkID, soundProperty.type, value) != E_OK) return E_UNKNOWN;
139 if (value == soundProperty.value) return E_NO_CHANGE;
140 return mRoutingSender->asyncSetSinkSoundProperty(handle, sinkID, soundProperty);
143 am_Error_e ControlReceiver::setSinkSoundProperties(am_Handle_s & handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s> & listSoundProperties)
145 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSinkSoundProperties got called, sinkID="), DLT_INT(sinkID));
148 bool noChange = true;
149 std::vector<am_SoundProperty_s>::const_iterator it = listSoundProperties.begin();
150 for (; it != listSoundProperties.end(); ++it)
152 if (mDatabaseHandler->getSinkSoundPropertyValue(sinkID, it->type, value) != E_OK) return (E_UNKNOWN);
153 if (value != it->value) noChange = false;
155 if (noChange) return (E_NO_CHANGE);
156 return (mRoutingSender->asyncSetSinkSoundProperties(handle, listSoundProperties, sinkID));
159 am_Error_e ControlReceiver::setSourceSoundProperty(am_Handle_s & handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty)
161 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceSoundProperty got called, sourceID="), DLT_INT(sourceID), DLT_STRING("soundProperty.Type="), DLT_INT(soundProperty.type), DLT_STRING("soundProperty.value="), DLT_INT(soundProperty.value));
164 if (mDatabaseHandler->getSourceSoundPropertyValue(sourceID, soundProperty.type, value) != E_OK) return E_UNKNOWN;
165 if (value == soundProperty.value) return E_NO_CHANGE;
166 return mRoutingSender->asyncSetSourceSoundProperty(handle, sourceID, soundProperty);
169 am_Error_e ControlReceiver::setSourceSoundProperties(am_Handle_s & handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s> & listSoundProperties)
171 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setSourceSoundProperties got called, sourceID="), DLT_INT(sourceID));
174 bool noChange = true;
175 std::vector<am_SoundProperty_s>::const_iterator it = listSoundProperties.begin();
176 for (; it != listSoundProperties.end(); ++it)
178 if (mDatabaseHandler->getSourceSoundPropertyValue(sourceID, it->type, value) != E_OK) return (E_UNKNOWN);
179 if (value != it->value) noChange = false;
181 if (noChange) return (E_NO_CHANGE);
182 return (mRoutingSender->asyncSetSourceSoundProperties(handle, listSoundProperties, sourceID));
185 am_Error_e ControlReceiver::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState)
187 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setDomainState got called, domainID="), DLT_INT(domainID), DLT_STRING("domainState="), DLT_INT(domainState));
189 am_DomainState_e tempState = DS_MIN;
190 if (mDatabaseHandler->getDomainState(domainID, tempState) != E_OK) return E_UNKNOWN;
191 if (tempState == domainState) return E_NO_CHANGE;
192 return mRoutingSender->setDomainState(domainID, domainState);
195 am_Error_e ControlReceiver::abortAction(const am_Handle_s handle)
197 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::abortAction got called, handle.type="), DLT_INT(handle.handle), DLT_STRING("handle.handleType="), DLT_INT(handle.handleType));
199 return mRoutingSender->asyncAbort(handle);
202 am_Error_e ControlReceiver::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
204 return mDatabaseHandler->enterDomainDB(domainData, domainID);
207 am_Error_e ControlReceiver::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
209 return mDatabaseHandler->enterMainConnectionDB(mainConnectionData, connectionID);
212 am_Error_e ControlReceiver::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
214 return mDatabaseHandler->enterSinkDB(sinkData, sinkID);
217 am_Error_e ControlReceiver::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
219 return mDatabaseHandler->enterCrossfaderDB(crossfaderData, crossfaderID);
222 am_Error_e ControlReceiver::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
224 return mDatabaseHandler->enterGatewayDB(gatewayData, gatewayID);
227 am_Error_e ControlReceiver::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
229 return mDatabaseHandler->enterSourceDB(sourceData, sourceID);
232 am_Error_e ControlReceiver::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
234 return mDatabaseHandler->enterSinkClassDB(sinkClass, sinkClassID);
237 am_Error_e ControlReceiver::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
239 return mDatabaseHandler->enterSourceClassDB(sourceClassID, sourceClass);
242 am_Error_e ControlReceiver::enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s> & listSystemProperties)
244 return mDatabaseHandler->enterSystemProperties(listSystemProperties);
247 am_Error_e ControlReceiver::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const am_Route_s & route)
249 return mDatabaseHandler->changeMainConnectionRouteDB(mainconnectionID, route);
252 am_Error_e ControlReceiver::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
254 return mDatabaseHandler->changeMainConnectionStateDB(mainconnectionID, connectionState);
257 am_Error_e ControlReceiver::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
259 return mDatabaseHandler->changeSinkMainVolumeDB(mainVolume, sinkID);
262 am_Error_e ControlReceiver::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
264 return mDatabaseHandler->changeSinkAvailabilityDB(availability, sinkID);
267 am_Error_e ControlReceiver::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
269 return mDatabaseHandler->changDomainStateDB(domainState, domainID);
272 am_Error_e ControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
274 return mDatabaseHandler->changeSinkMuteStateDB(muteState, sinkID);
277 am_Error_e ControlReceiver::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
279 return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty, sinkID);
282 am_Error_e ControlReceiver::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
284 return mDatabaseHandler->changeMainSinkSoundPropertyDB(soundProperty, sourceID);
287 am_Error_e ControlReceiver::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
289 return mDatabaseHandler->changeSourceAvailabilityDB(availability, sourceID);
292 am_Error_e ControlReceiver::changeSystemPropertyDB(const am_SystemProperty_s & property)
294 return mDatabaseHandler->changeSystemPropertyDB(property);
297 am_Error_e ControlReceiver::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
299 return mDatabaseHandler->removeMainConnectionDB(mainConnectionID);
302 am_Error_e ControlReceiver::removeSinkDB(const am_sinkID_t sinkID)
304 return mDatabaseHandler->removeSinkDB(sinkID);
307 am_Error_e ControlReceiver::removeSourceDB(const am_sourceID_t sourceID)
309 return mDatabaseHandler->removeSourceDB(sourceID);
312 am_Error_e ControlReceiver::removeGatewayDB(const am_gatewayID_t gatewayID)
314 return mDatabaseHandler->removeGatewayDB(gatewayID);
317 am_Error_e ControlReceiver::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
319 return mDatabaseHandler->removeCrossfaderDB(crossfaderID);
322 am_Error_e ControlReceiver::removeDomainDB(const am_domainID_t domainID)
324 return mDatabaseHandler->removeDomainDB(domainID);
327 am_Error_e ControlReceiver::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
329 return mDatabaseHandler->getSourceClassInfoDB(sourceID, classInfo);
332 am_Error_e ControlReceiver::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
334 return mDatabaseHandler->getSinkClassInfoDB(sinkID, sinkClass);
337 am_Error_e ControlReceiver::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
339 return mDatabaseHandler->getGatewayInfoDB(gatewayID, gatewayData);
342 am_Error_e ControlReceiver::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
344 return mDatabaseHandler->getCrossfaderInfoDB(crossfaderID, crossfaderData);
347 am_Error_e ControlReceiver::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
349 return mDatabaseHandler->getListSinksOfDomain(domainID, listSinkID);
352 am_Error_e ControlReceiver::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
354 return mDatabaseHandler->getListSourcesOfDomain(domainID, listSourceID);
357 am_Error_e ControlReceiver::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
359 return mDatabaseHandler->getListCrossfadersOfDomain(domainID, listGatewaysID);
362 am_Error_e ControlReceiver::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
364 return mDatabaseHandler->getListGatewaysOfDomain(domainID, listGatewaysID);
367 am_Error_e ControlReceiver::getListMainConnections(std::vector<am_MainConnection_s> & listMainConnections) const
369 return mDatabaseHandler->getListMainConnections(listMainConnections);
372 am_Error_e ControlReceiver::getListDomains(std::vector<am_Domain_s> & listDomains) const
374 return mDatabaseHandler->getListDomains(listDomains);
377 am_Error_e ControlReceiver::getListConnections(std::vector<am_Connection_s> & listConnections) const
379 return mDatabaseHandler->getListConnections(listConnections);
382 am_Error_e ControlReceiver::getListSinks(std::vector<am_Sink_s> & listSinks) const
384 return mDatabaseHandler->getListSinks(listSinks);
387 am_Error_e ControlReceiver::getListSources(std::vector<am_Source_s> & listSources) const
389 return mDatabaseHandler->getListSources(listSources);
392 am_Error_e ControlReceiver::getListSourceClasses(std::vector<am_SourceClass_s> & listSourceClasses) const
394 return mDatabaseHandler->getListSourceClasses(listSourceClasses);
397 am_Error_e ControlReceiver::getListHandles(std::vector<am_Handle_s> & listHandles) const
399 return mRoutingSender->getListHandles(listHandles);
402 am_Error_e ControlReceiver::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
404 return mDatabaseHandler->getListCrossfaders(listCrossfaders);
407 am_Error_e ControlReceiver::getListGateways(std::vector<am_Gateway_s> & listGateways) const
409 return mDatabaseHandler->getListGateways(listGateways);
412 am_Error_e ControlReceiver::getListSinkClasses(std::vector<am_SinkClass_s> & listSinkClasses) const
414 return mDatabaseHandler->getListSinkClasses(listSinkClasses);
417 am_Error_e ControlReceiver::getListSystemProperties(std::vector<am_SystemProperty_s> & listSystemProperties) const
419 return mDatabaseHandler->getListSystemProperties(listSystemProperties);
422 am_Error_e ControlReceiver::changeSinkClassInfoDB(const am_SinkClass_s & classInfo)
424 return mDatabaseHandler->changeSinkClassInfoDB(classInfo);
427 am_Error_e ControlReceiver::changeSourceClassInfoDB(const am_SourceClass_s & classInfo)
429 return mDatabaseHandler->changeSourceClassInfoDB(classInfo);
432 am_Error_e ControlReceiver::removeSinkClassDB(const am_sinkClass_t sinkClassID)
434 return mDatabaseHandler->removeSinkClassDB(sinkClassID);
437 am_Error_e ControlReceiver::removeSourceClassDB(const am_sourceClass_t sourceClassID)
439 return mDatabaseHandler->removeSourceClassDB(sourceClassID);
442 void ControlReceiver::setCommandReady()
444 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setCommandReady got called"));
445 mCommandSender->cbCommunicationReady();
448 void ControlReceiver::setRoutingReady()
450 DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("ControlReceiver::setRoutingReady got called"));
451 mRoutingSender->routingInterfacesReady();
454 am_Error_e ControlReceiver::getSocketHandler(SocketHandler *& socketHandler)
456 #ifdef WITH_SOCKETHANDLER_LOOP
457 socketHandler = mSocketHandler;
464 uint16_t ControlReceiver::getInterfaceVersion() const
466 return ControlReceiveVersion;