From 1111f28e3693ee0f296819654a5c35fe147c395d Mon Sep 17 00:00:00 2001 From: Christian as GENIVI Maintainer Date: Fri, 30 Sep 2016 08:11:30 -0700 Subject: add doxygen documentation for github Signed-off-by: Christian as GENIVI Maintainer --- docs/CAmControlSender_8cpp_source.html | 844 +++++++++++++++++++++++++++++++++ 1 file changed, 844 insertions(+) create mode 100644 docs/CAmControlSender_8cpp_source.html (limited to 'docs/CAmControlSender_8cpp_source.html') diff --git a/docs/CAmControlSender_8cpp_source.html b/docs/CAmControlSender_8cpp_source.html new file mode 100644 index 0000000..8e1b915 --- /dev/null +++ b/docs/CAmControlSender_8cpp_source.html @@ -0,0 +1,844 @@ + + + + + + +AudioManager: AudioManagerCore/src/CAmControlSender.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
AudioManager +  7.5.11 +
+
Native Application Runtime Environment
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
CAmControlSender.cpp
+
+
+Go to the documentation of this file.
1 
+
24 #include "CAmControlSender.h"
+
25 #include <cassert>
+
26 #include <fstream>
+
27 #include <iostream>
+
28 #include <sstream>
+
29 #include <stdexcept>
+
30 #include <sys/stat.h>
+
31 #include <sys/types.h>
+
32 #include <dirent.h>
+
33 #include "TAmPluginTemplate.h"
+
34 #include "CAmDltWrapper.h"
+
35 
+
36 namespace am
+
37 {
+
38 
+
39 #define REQUIRED_INTERFACE_VERSION_MAJOR 1
+
40 #define REQUIRED_INTERFACE_VERSION_MINOR 0
+
41 
+
42 CAmControlSender* CAmControlSender::mInstance=NULL;
+
43 
+
44 CAmControlSender::CAmControlSender(std::string controlPluginFile,CAmSocketHandler* sockethandler) :
+
45  receiverCallbackT(this, &CAmControlSender::receiverCallback),//
+
46  checkerCallbackT(this, &CAmControlSender::checkerCallback),//
+
47  dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback), //
+
48  mPipe(), //
+
49  mlibHandle(NULL), //
+
50  mController(NULL), //
+
51  mSignal(0)
+
52 {
+
53  assert(sockethandler);
+
54 
+
55  //Check if a folder is given, then select the first plugin
+
56  struct stat buf;
+
57  const char* conFile(controlPluginFile.c_str());
+
58  stat(conFile, &buf);
+
59  if (S_ISDIR(buf.st_mode))
+
60  {
+
61  std::string directoryName(controlPluginFile);
+
62  logInfo("Searching for ControlPlugin in", directoryName);
+
63  DIR *directory = opendir(directoryName.c_str());
+
64 
+
65  if (!directory)
+
66  {
+
67  logError("Error opening directory ", directoryName);
+
68  throw std::runtime_error("Controller directory could not be openend");
+
69  }
+
70 
+
71  // iterate content of directory
+
72  struct dirent *itemInDirectory = 0;
+
73  while ((itemInDirectory = readdir(directory)))
+
74  {
+
75  unsigned char entryType = itemInDirectory->d_type;
+
76  std::string entryName = itemInDirectory->d_name;
+
77  std::string fullName = directoryName + "/" + entryName;
+
78 
+
79  bool regularFile = (entryType == DT_REG || entryType == DT_LNK);
+
80  bool sharedLibExtension = ("so" == entryName.substr(entryName.find_last_of(".") + 1));
+
81 
+
82  // Handle cases where readdir() could not determine the file type
+
83  if (entryType == DT_UNKNOWN) {
+
84  struct stat buf;
+
85 
+
86  if (stat(fullName.c_str(), &buf)) {
+
87  logInfo(__PRETTY_FUNCTION__,"Failed to stat file: ", entryName, errno);
+
88  continue;
+
89  }
+
90 
+
91  regularFile = S_ISREG(buf.st_mode);
+
92  }
+
93 
+
94  if (regularFile && sharedLibExtension)
+
95  {
+
96  controlPluginFile=directoryName + "/" + entryName;
+
97  logInfo("Found ControlPlugin:", controlPluginFile);
+
98  break;
+
99  }
+
100  }
+
101  closedir(directory);
+
102 
+
103  }
+
104 
+
105  std::ifstream isfile(controlPluginFile.c_str());
+
106  if (!isfile)
+
107  {
+
108  logError("ControlSender::ControlSender: Controller plugin not found:", controlPluginFile);
+
109  throw std::runtime_error("Could not find controller plugin!");
+
110  }
+
111  else if (!controlPluginFile.empty())
+
112  {
+
113  mInstance=this;
+
114  IAmControlSend* (*createFunc)();
+
115  createFunc = getCreateFunction<IAmControlSend*()>(controlPluginFile, mlibHandle);
+
116  assert(createFunc!=NULL);
+
117  mController = createFunc();
+
118 
+
119  //check libversion
+
120  std::string version, cVersion(ControlVersion);
+
121  mController->getInterfaceVersion(version);
+
122  uint16_t minorVersion, majorVersion, cMinorVersion, cMajorVersion;
+
123  std::istringstream(version.substr(0, 1)) >> majorVersion;
+
124  std::istringstream(version.substr(2, 1)) >> minorVersion;
+
125  std::istringstream(cVersion.substr(0, 1)) >> cMajorVersion;
+
126  std::istringstream(cVersion.substr(2, 1)) >> cMinorVersion;
+
127 
+
128 
+
129 
+
130  if (majorVersion < cMajorVersion || ((majorVersion == cMajorVersion) && (minorVersion < cMinorVersion)))
+
131  {
+
132  logError("ControlSender::ControlSender: Interface Version of Controller too old, required version:",ControlVersion," Controller Version:",version,"exiting now");
+
133  throw std::runtime_error("Interface Version of Controller too old");
+
134  }
+
135  }
+
136  else
+
137  {
+
138  logError("ControlSender::ControlSender: No controller loaded !");
+
139  }
+
140 
+
141  //here we need a pipe to be able to call the rundown function out of the mainloop
+
142  if (pipe(mPipe) == -1)
+
143  {
+
144  logError("CAmControlSender could not create pipe!");
+
145  }
+
146 
+
147  //add the pipe to the poll - nothing needs to be proccessed here we just need the pipe to trigger the ppoll
+
148  short event = 0;
+
149  sh_pollHandle_t handle;
+
150  event |= POLLIN;
+
151  sockethandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, handle);
+
152 }
+
153 
+
154 CAmControlSender::~CAmControlSender()
+
155 {
+
156  close(mPipe[0]);
+
157  close(mPipe[1]);
+
158  //if (mlibHandle)
+
159  // dlclose(mlibHandle);
+
160 }
+
161 
+
162 am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
+
163 {
+
164  assert(mController);
+
165  return (mController->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID));
+
166 }
+
167 
+
168 am_Error_e CAmControlSender::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
+
169 {
+
170  assert(mController);
+
171  return (mController->hookUserDisconnectionRequest(connectionID));
+
172 }
+
173 
+
174 am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
+
175 {
+
176  assert(mController);
+
177  return (mController->hookUserSetMainSinkSoundProperty(sinkID, soundProperty));
+
178 }
+
179 
+
180 am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
+
181 {
+
182  assert(mController);
+
183  return (mController->hookUserSetMainSourceSoundProperty(sourceID, soundProperty));
+
184 }
+
185 
+
186 am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
+
187 {
+
188  assert(mController);
+
189  return (mController->hookUserSetSystemProperty(property));
+
190 }
+
191 
+
192 am_Error_e CAmControlSender::hookUserVolumeChange(const am_sinkID_t sinkID, const am_mainVolume_t newVolume)
+
193 {
+
194  assert(mController);
+
195  return (mController->hookUserVolumeChange(sinkID, newVolume));
+
196 }
+
197 
+
198 am_Error_e CAmControlSender::hookUserVolumeStep(const am_sinkID_t sinkID, const int16_t increment)
+
199 {
+
200  assert(mController);
+
201  return (mController->hookUserVolumeStep(sinkID, increment));
+
202 }
+
203 
+
204 am_Error_e CAmControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
+
205 {
+
206  assert(mController);
+
207  return (mController->hookUserSetSinkMuteState(sinkID, muteState));
+
208 }
+
209 
+
210 am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
+
211 {
+
212  assert(mController);
+
213  return (mController->hookSystemRegisterDomain(domainData, domainID));
+
214 }
+
215 
+
216 am_Error_e CAmControlSender::hookSystemDeregisterDomain(const am_domainID_t domainID)
+
217 {
+
218  assert(mController);
+
219  return (mController->hookSystemDeregisterDomain(domainID));
+
220 }
+
221 
+
222 void CAmControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
+
223 {
+
224  assert(mController);
+
225  return (mController->hookSystemDomainRegistrationComplete(domainID));
+
226 }
+
227 
+
228 am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
+
229 {
+
230  assert(mController);
+
231  return (mController->hookSystemRegisterSink(sinkData, sinkID));
+
232 }
+
233 
+
234 am_Error_e CAmControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
+
235 {
+
236  assert(mController);
+
237  return (mController->hookSystemDeregisterSink(sinkID));
+
238 }
+
239 
+
240 am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
+
241 {
+
242  assert(mController);
+
243  return (mController->hookSystemRegisterSource(sourceData, sourceID));
+
244 }
+
245 
+
246 am_Error_e CAmControlSender::hookSystemDeregisterSource(const am_sourceID_t sourceID)
+
247 {
+
248  assert(mController);
+
249  return (mController->hookSystemDeregisterSource(sourceID));
+
250 }
+
251 
+
252 am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
+
253 {
+
254  assert(mController);
+
255  return (mController->hookSystemRegisterGateway(gatewayData, gatewayID));
+
256 }
+
257 
+
258 am_Error_e CAmControlSender::hookSystemRegisterConverter(const am_Converter_s& converterData, am_converterID_t& converterID)
+
259 {
+
260  assert(mController);
+
261  return (mController->hookSystemRegisterConverter(converterData, converterID));
+
262 }
+
263 
+
264 am_Error_e CAmControlSender::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
+
265 {
+
266  assert(mController);
+
267  return (mController->hookSystemDeregisterGateway(gatewayID));
+
268 }
+
269 
+
270 am_Error_e CAmControlSender::hookSystemDeregisterConverter(const am_converterID_t converterID)
+
271 {
+
272  assert(mController);
+
273  return (mController->hookSystemDeregisterConverter(converterID));
+
274 }
+
275 
+
276 am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
+
277 {
+
278  assert(mController);
+
279  return (mController->hookSystemRegisterCrossfader(crossfaderData, crossfaderID));
+
280 }
+
281 
+
282 am_Error_e CAmControlSender::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
+
283 {
+
284  assert(mController);
+
285  return (mController->hookSystemDeregisterCrossfader(crossfaderID));
+
286 }
+
287 
+
288 void CAmControlSender::hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
+
289 {
+
290  assert(mController);
+
291  mController->hookSystemSinkVolumeTick(handle, sinkID, volume);
+
292 }
+
293 
+
294 void CAmControlSender::hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
+
295 {
+
296  assert(mController);
+
297  mController->hookSystemSourceVolumeTick(handle, sourceID, volume);
+
298 }
+
299 
+
300 void CAmControlSender::hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
+
301 {
+
302  assert(mController);
+
303  mController->hookSystemInterruptStateChange(sourceID, interruptState);
+
304 }
+
305 
+
306 void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
+
307 {
+
308  assert(mController);
+
309  mController->hookSystemSinkAvailablityStateChange(sinkID, availability);
+
310 }
+
311 
+
312 void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
+
313 {
+
314  assert(mController);
+
315  mController->hookSystemSourceAvailablityStateChange(sourceID, availability);
+
316 }
+
317 
+
318 void CAmControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
+
319 {
+
320  assert(mController);
+
321  mController->hookSystemDomainStateChange(domainID, state);
+
322 }
+
323 
+
324 void CAmControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
+
325 {
+
326  assert(mController);
+
327  mController->hookSystemReceiveEarlyData(data);
+
328 }
+
329 
+
330 void CAmControlSender::hookSystemSpeedChange(const am_speed_t speed)
+
331 {
+
332  assert(mController);
+
333  mController->hookSystemSpeedChange(speed);
+
334 }
+
335 
+
336 void CAmControlSender::hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
+
337 {
+
338  assert(mController);
+
339  mController->hookSystemTimingInformationChanged(mainConnectionID, time);
+
340 }
+
341 
+
342 void CAmControlSender::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
+
343 {
+
344  assert(mController);
+
345  mController->cbAckConnect(handle, errorID);
+
346 }
+
347 
+
348 void CAmControlSender::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
+
349 {
+
350  assert(mController);
+
351  mController->cbAckDisconnect(handle, errorID);
+
352 }
+
353 
+
354 void CAmControlSender::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
+
355 {
+
356  assert(mController);
+
357  mController->cbAckCrossFade(handle, hostsink, error);
+
358 }
+
359 
+
360 void CAmControlSender::cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
+
361 {
+
362  assert(mController);
+
363  mController->cbAckSetSinkVolumeChange(handle, volume, error);
+
364 }
+
365 
+
366 void CAmControlSender::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
+
367 {
+
368  assert(mController);
+
369  mController->cbAckSetSourceVolumeChange(handle, volume, error);
+
370 }
+
371 
+
372 void CAmControlSender::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
+
373 {
+
374  assert(mController);
+
375  mController->cbAckSetSourceState(handle, error);
+
376 }
+
377 
+
378 void CAmControlSender::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
+
379 {
+
380  assert(mController);
+
381  mController->cbAckSetSourceSoundProperty(handle, error);
+
382 }
+
383 
+
384 am_Error_e CAmControlSender::startupController(IAmControlReceive *controlreceiveinterface)
+
385 {
+
386  if (!mController)
+
387  {
+
388  logError("ControlSender::startupController: no Controller to startup!");
+
389  throw std::runtime_error("ControlSender::startupController: no Controller to startup! Exiting now ...");
+
390  return (E_NON_EXISTENT);
+
391  }
+
392  return (mController->startupController(controlreceiveinterface));
+
393 }
+
394 
+
395 void CAmControlSender::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
+
396 {
+
397  assert(mController);
+
398  mController->cbAckSetSinkSoundProperty(handle, error);
+
399 }
+
400 
+
401 void CAmControlSender::cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
+
402 {
+
403  assert(mController);
+
404  mController->cbAckSetSinkSoundProperties(handle, error);
+
405 }
+
406 
+
407 void CAmControlSender::cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
+
408 {
+
409  assert(mController);
+
410  mController->cbAckSetSourceSoundProperties(handle, error);
+
411 }
+
412 
+
413 void CAmControlSender::setControllerReady()
+
414 {
+
415  assert(mController);
+
416  mController->setControllerReady();
+
417 }
+
418 
+
419 void CAmControlSender::setControllerRundown(const int16_t signal)
+
420 {
+
421  assert(mController);
+
422  logInfo("CAmControlSender::setControllerRundown received, signal=",signal);
+
423  mController->setControllerRundown(signal);
+
424 }
+
425 
+
426 am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_CustomConnectionFormat_t> listPossibleConnectionFormats, std::vector<am_CustomConnectionFormat_t> & listPrioConnectionFormats)
+
427 {
+
428  assert(mController);
+
429  return (mController->getConnectionFormatChoice(sourceID, sinkID, listRoute, listPossibleConnectionFormats, listPrioConnectionFormats));
+
430 }
+
431 
+
432 void CAmControlSender::getInterfaceVersion(std::string & version) const
+
433 {
+
434  version = ControlVersion;
+
435 }
+
436 
+
437 void CAmControlSender::confirmCommandReady(const am_Error_e error)
+
438 {
+
439  assert(mController);
+
440  mController->confirmCommandReady(error);
+
441 }
+
442 
+
443 void CAmControlSender::confirmRoutingReady(const am_Error_e error)
+
444 {
+
445  assert(mController);
+
446  mController->confirmRoutingReady(error);
+
447 }
+
448 
+
449 void CAmControlSender::confirmCommandRundown(const am_Error_e error)
+
450 {
+
451  assert(mController);
+
452  mController->confirmCommandRundown(error);
+
453 }
+
454 
+
455 void CAmControlSender::confirmRoutingRundown(const am_Error_e error)
+
456 {
+
457  assert(mController);
+
458  mController->confirmRoutingRundown(error);
+
459 }
+
460 
+
461 am_Error_e CAmControlSender::hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+
462 {
+
463  assert(mController);
+
464  return (mController->hookSystemUpdateSink(sinkID,sinkClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+
465 }
+
466 
+
467 am_Error_e CAmControlSender::hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
+
468 {
+
469  assert(mController);
+
470  return (mController->hookSystemUpdateSource(sourceID,sourceClassID,listSoundProperties,listConnectionFormats,listMainSoundProperties));
+
471 }
+
472 
+
473 am_Error_e CAmControlSender::hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFromats, const std::vector<bool>& convertionMatrix)
+
474 {
+
475  assert(mController);
+
476  return (mController->hookSystemUpdateGateway(gatewayID,listSourceConnectionFormats,listSinkConnectionFromats,convertionMatrix));
+
477 }
+
478 
+
479 am_Error_e CAmControlSender::hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFromats, const std::vector<bool>& convertionMatrix)
+
480 {
+
481  assert(mController);
+
482  return (mController->hookSystemUpdateConverter(converterID,listSourceConnectionFormats,listSinkConnectionFromats,convertionMatrix));
+
483 }
+
484 
+
485 void CAmControlSender::cbAckSetVolume(const am_Handle_s handle, const std::vector<am_Volumes_s>& listVolumes, const am_Error_e error)
+
486 {
+
487  assert(mController);
+
488  mController->cbAckSetVolumes(handle,listVolumes,error);
+
489 }
+
490 
+
491 void CAmControlSender::cbAckSetSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
+
492 {
+
493  assert(mController);
+
494  mController->cbAckSetSinkNotificationConfiguration(handle,error);
+
495 }
+
496 
+
497 void CAmControlSender::cbAckSetSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
+
498 {
+
499  assert(mController);
+
500  mController->cbAckSetSourceNotificationConfiguration(handle,error);
+
501 }
+
502 
+
503 void CAmControlSender::hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s& payload)
+
504 {
+
505  assert(mController);
+
506  mController->hookSinkNotificationDataChanged(sinkID,payload);
+
507 }
+
508 
+
509 void CAmControlSender::hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s& payload)
+
510 {
+
511  assert(mController);
+
512  mController->hookSourceNotificationDataChanged(sourceID,payload);
+
513 }
+
514 
+
515 am_Error_e CAmControlSender::hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s& notificationConfiguration)
+
516 {
+
517  assert(mController);
+
518  return (mController->hookUserSetMainSinkNotificationConfiguration(sinkID,notificationConfiguration));
+
519 }
+
520 
+
521 am_Error_e CAmControlSender::hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s& notificationConfiguration)
+
522 {
+
523  assert(mController);
+
524  return (mController->hookUserSetMainSourceNotificationConfiguration(sourceID,notificationConfiguration));
+
525 }
+
526 
+
527 void CAmControlSender::receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)
+
528 {
+
529  (void) handle;
+
530  (void) userData;
+
531  //get the signal number from the socket
+
532  ssize_t result = read(pollfd.fd, &mSignal, sizeof(mSignal));
+
533 }
+
534 
+
535 bool CAmControlSender::checkerCallback(const sh_pollHandle_t handle, void* userData)
+
536 {
+
537  (void) handle;
+
538  (void) userData;
+
539  return (true);
+
540 }
+
541 
+
542 void CAmControlSender::hookSystemSingleTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t time)
+
543 {
+
544  assert(mController);
+
545  mController->hookSystemSingleTimingInformationChanged(connectionID,time);
+
546 }
+
547 
+
551 CAmControlSender::CAmControlSender() :
+
552  receiverCallbackT(this, &CAmControlSender::receiverCallback),//
+
553  checkerCallbackT(this, &CAmControlSender::checkerCallback),//
+
554  dispatcherCallbackT(this, &CAmControlSender::dispatcherCallback), //
+
555  mPipe(), //
+
556  mlibHandle(NULL), //
+
557  mController(NULL), //
+
558  mSignal(0)
+
559 {
+
560  logInfo("CAmControlSender was loaded in test mode!");
+
561 }
+
562 
+
563 bool CAmControlSender::dispatcherCallback(const sh_pollHandle_t handle, void* userData)
+
564 {
+
565  (void)handle;
+
566  (void)userData;
+
567  setControllerRundown(mSignal);
+
568  return (false);
+
569 }
+
570 
+
571 }
+
572 
+
573 
+ +
am::am_connectionID_t
uint16_t am_connectionID_t
a connection ID
Definition: audiomanagertypes.h:55
+
am::CAmControlSender::checkerCallback
bool checkerCallback(const sh_pollHandle_t handle, void *userData)
Definition: CAmControlSender.cpp:535
+
am::CAmControlSender::dispatcherCallback
bool dispatcherCallback(const sh_pollHandle_t handle, void *userData)
Definition: CAmControlSender.cpp:563
+
am::CAmControlSender::hookUserVolumeChange
am_Error_e hookUserVolumeChange(const am_sinkID_t SinkID, const am_mainVolume_t newVolume)
Definition: CAmControlSender.cpp:192
+
am::CAmControlSender::getInterfaceVersion
void getInterfaceVersion(std::string &version) const
Definition: CAmControlSender.cpp:432
+
am::CAmControlSender::hookSystemSourceAvailablityStateChange
void hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s &availability)
Definition: CAmControlSender.cpp:312
+
am::CAmControlSender::hookSystemUpdateGateway
am_Error_e hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector< am_CustomConnectionFormat_t > &listSourceConnectionFormats, const std::vector< am_CustomConnectionFormat_t > &listSinkConnectionFromats, const std::vector< bool > &convertionMatrix)
Definition: CAmControlSender.cpp:473
+
am::IAmControlSend::hookUserVolumeChange
virtual am_Error_e hookUserVolumeChange(const am_sinkID_t SinkID, const am_mainVolume_t newVolume)=0
sets a user volume
+
am::E_NON_EXISTENT
the desired object is non existent
Definition: audiomanagertypes.h:374
+
am::CAmControlSender::cbAckSetSinkSoundProperties
void cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:401
+
am::am_sinkClass_t
uint16_t am_sinkClass_t
Definition: audiomanagertypes.h:104
+
am::am_Error_e
am_Error_e
the errors of the audiomanager.
Definition: audiomanagertypes.h:337
+
am::am_InterruptState_e
am_InterruptState_e
Definition: audiomanagertypes.h:454
+
am::CAmControlSender::hookUserSetMainSinkSoundProperty
am_Error_e hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s &soundProperty)
Definition: CAmControlSender.cpp:174
+
am::am_NotificationConfiguration_s
This struct holds information about the configuration for notifications.
Definition: audiomanagertypes.h:1109
+
am::CAmControlSender::hookSystemRegisterSink
am_Error_e hookSystemRegisterSink(const am_Sink_s &sinkData, am_sinkID_t &sinkID)
Definition: CAmControlSender.cpp:228
+
am::CAmControlSender::hookSystemDeregisterCrossfader
am_Error_e hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
Definition: CAmControlSender.cpp:282
+
am::logInfo
void logInfo(T value, TArgs...args)
logs given values with infolevel with the default context
Definition: CAmDltWrapper.h:405
+
am::IAmControlSend::hookSystemDomainStateChange
virtual void hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)=0
id called when domainstate was changed
+
am::CAmControlSender::hookUserDisconnectionRequest
am_Error_e hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
Definition: CAmControlSender.cpp:168
+ +
am::CAmControlSender::hookSystemInterruptStateChange
void hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
Definition: CAmControlSender.cpp:300
+
am::CAmControlSender::hookSystemDomainRegistrationComplete
void hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
Definition: CAmControlSender.cpp:222
+
am::am_Sink_s
This struct describes the attribiutes of a sink.
Definition: audiomanagertypes.h:1137
+
am::am_NotificationPayload_s
This struct holds the payload of a notification.
Definition: audiomanagertypes.h:1090
+
am::IAmControlSend::hookSystemDeregisterCrossfader
virtual am_Error_e hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)=0
is called when a routing adaptor deregisters a crossfader
+
am::CAmControlSender::cbAckSetSinkNotificationConfiguration
void cbAckSetSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:491
+
am::CAmControlSender::confirmRoutingReady
void confirmRoutingReady(const am_Error_e error)
Definition: CAmControlSender.cpp:443
+
am::IAmControlSend::setControllerReady
virtual void setControllerReady()=0
this message is used tell the controller that it should get ready.
+
am::IAmControlSend::hookSystemUpdateSource
virtual am_Error_e hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector< am_SoundProperty_s > &listSoundProperties, const std::vector< am_CustomConnectionFormat_t > &listConnectionFormats, const std::vector< am_MainSoundProperty_s > &listMainSoundProperties)=0
update from the source Data
+
am::CAmControlSender::hookSinkNotificationDataChanged
void hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s &payload)
Definition: CAmControlSender.cpp:503
+
am::CAmControlSender::hookSystemDeregisterSink
am_Error_e hookSystemDeregisterSink(const am_sinkID_t sinkID)
Definition: CAmControlSender.cpp:234
+
am::am_Domain_s
This struct describes the attribiutes of a domain.
Definition: audiomanagertypes.h:1342
+
am::IAmControlSend::cbAckConnect
virtual void cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)=0
ack for connect
+
am::CAmControlSender::startupController
am_Error_e startupController(IAmControlReceive *controlreceiveinterface)
Definition: CAmControlSender.cpp:384
+
am::IAmControlSend::cbAckSetSinkVolumeChange
virtual void cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)=0
ack for sink volume changes
+
am::CAmControlSender::hookSystemUpdateSink
am_Error_e hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector< am_SoundProperty_s > &listSoundProperties, const std::vector< am_CustomConnectionFormat_t > &listConnectionFormats, const std::vector< am_MainSoundProperty_s > &listMainSoundProperties)
Definition: CAmControlSender.cpp:461
+
ControlVersion
#define ControlVersion
Definition: IAmControl.h:35
+
am::am_crossfaderID_t
uint16_t am_crossfaderID_t
a crossfader ID
Definition: audiomanagertypes.h:50
+
am::CAmSocketHandler
The am::CAmSocketHandler implements a mainloop for the AudioManager.
Definition: CAmSocketHandler.h:94
+
am::IAmControlSend::hookSinkNotificationDataChanged
virtual void hookSinkNotificationDataChanged(const am_sinkID_t sinkID, const am_NotificationPayload_s &payload)=0
new sinkNotification data is there!
+
am::CAmControlSender::hookUserSetSystemProperty
am_Error_e hookUserSetSystemProperty(const am_SystemProperty_s &property)
Definition: CAmControlSender.cpp:186
+
am::CAmControlSender::confirmCommandReady
void confirmCommandReady(const am_Error_e error)
Definition: CAmControlSender.cpp:437
+
am::IAmControlSend::hookSystemSpeedChange
virtual void hookSystemSpeedChange(const am_speed_t speed)=0
this hook provides information about speed changes.
+
am::CAmControlSender::checkerCallbackT
TAmShPollCheck< CAmControlSender > checkerCallbackT
Definition: CAmControlSender.h:121
+
am::CAmControlSender::hookSystemSinkAvailablityStateChange
void hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s &availability)
Definition: CAmControlSender.cpp:306
+
am::am_timeSync_t
int16_t am_timeSync_t
offset time that is introduced in milli seconds.
Definition: audiomanagertypes.h:114
+
am::CAmControlSender::hookSourceNotificationDataChanged
void hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s &payload)
Definition: CAmControlSender.cpp:509
+
am::IAmControlSend::hookSourceNotificationDataChanged
virtual void hookSourceNotificationDataChanged(const am_sourceID_t sourceID, const am_NotificationPayload_s &payload)=0
new sourceNotification data is there!
+
am::CAmControlSender::hookSystemRegisterSource
am_Error_e hookSystemRegisterSource(const am_Source_s &sourceData, am_sourceID_t &sourceID)
Definition: CAmControlSender.cpp:240
+
am::sh_pollHandle_t
uint16_t sh_pollHandle_t
this is a handle for a filedescriptor to be used with the SocketHandler
Definition: CAmSocketHandler.h:37
+
am::CAmControlSender::receiverCallback
void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
Definition: CAmControlSender.cpp:527
+
CAmDltWrapper.h
SPDX license identifier: MPL-2.0.
+
am::CAmControlSender::hookSystemDomainStateChange
void hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
Definition: CAmControlSender.cpp:318
+
am::CAmControlSender::hookSystemRegisterConverter
am_Error_e hookSystemRegisterConverter(const am_Converter_s &converterData, am_converterID_t &converterID)
Definition: CAmControlSender.cpp:258
+
am::IAmControlSend::hookUserVolumeStep
virtual am_Error_e hookUserVolumeStep(const am_sinkID_t SinkID, const int16_t increment)=0
sets a user volume as increment
+
am::CAmControlSender::getConnectionFormatChoice
am_Error_e getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector< am_CustomConnectionFormat_t > listPossibleConnectionFormats, std::vector< am_CustomConnectionFormat_t > &listPrioConnectionFormats)
Definition: CAmControlSender.cpp:426
+
am::IAmControlSend::hookSystemRegisterConverter
virtual am_Error_e hookSystemRegisterConverter(const am_Converter_s &converterData, am_converterID_t &converterID)=0
is called when a routing adaptor registers a converter
+
am::CAmControlSender::setControllerRundown
void setControllerRundown(const int16_t signal)
Definition: CAmControlSender.cpp:419
+
am::IAmControlSend::hookUserSetSystemProperty
virtual am_Error_e hookUserSetSystemProperty(const am_SystemProperty_s &property)=0
sets a user SystemProperty
+
am::CAmControlSender::cbAckCrossFade
void cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
Definition: CAmControlSender.cpp:354
+
am::CAmControlSender::cbAckSetSinkVolumeChange
void cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
Definition: CAmControlSender.cpp:360
+
am::IAmControlSend::cbAckSetSinkSoundProperties
virtual void cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)=0
ack for setting of sinksoundproperties
+
am::IAmControlSend::cbAckSetSourceNotificationConfiguration
virtual void cbAckSetSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)=0
The acknowledge of the source notification configuration.
+
am::IAmControlSend::hookUserSetMainSinkSoundProperty
virtual am_Error_e hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s &soundProperty)=0
sets a user MainSinkSoundProperty
+
am::CAmControlSender::cbAckDisconnect
void cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
Definition: CAmControlSender.cpp:348
+
am::CAmControlSender::cbAckSetSourceNotificationConfiguration
void cbAckSetSourceNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:497
+
am::IAmControlSend::hookUserSetMainSourceNotificationConfiguration
virtual am_Error_e hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &notificationConfiguration)=0
sets a user MainSourceNotificationConfiguration
+
am::CAmControlSender::hookSystemUpdateConverter
am_Error_e hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector< am_CustomConnectionFormat_t > &listSourceConnectionFormats, const std::vector< am_CustomConnectionFormat_t > &listSinkConnectionFromats, const std::vector< bool > &convertionMatrix)
Definition: CAmControlSender.cpp:479
+
am::CAmControlSender::CAmControlSender
CAmControlSender()
for testing only contructor - do not use !
Definition: CAmControlSender.cpp:551
+
am::am_SystemProperty_s
struct describing system properties
Definition: audiomanagertypes.h:850
+
am::CAmControlSender::hookSystemSinkVolumeTick
void hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
Definition: CAmControlSender.cpp:288
+
am::am_converterID_t
uint16_t am_converterID_t
a converter ID
Definition: audiomanagertypes.h:70
+
am::IAmControlSend::cbAckSetSinkNotificationConfiguration
virtual void cbAckSetSinkNotificationConfiguration(const am_Handle_s handle, const am_Error_e error)=0
The acknowledge of the sink notification configuration.
+
am::IAmControlSend::confirmRoutingReady
virtual void confirmRoutingReady(const am_Error_e error)=0
confirms the setRoutingReady call
+
am::IAmControlSend::hookSystemRegisterSource
virtual am_Error_e hookSystemRegisterSource(const am_Source_s &sourceData, am_sourceID_t &sourceID)=0
is called when a routing adaptor registers a source
+
am::am_MainSoundProperty_s
struct describung mainsound property
Definition: audiomanagertypes.h:1008
+
am::CAmControlSender::hookUserSetMainSourceNotificationConfiguration
am_Error_e hookUserSetMainSourceNotificationConfiguration(const am_sourceID_t sourceID, const am_NotificationConfiguration_s &notificationConfiguration)
Definition: CAmControlSender.cpp:521
+
am::CAmControlSender::receiverCallbackT
TAmShPollFired< CAmControlSender > receiverCallbackT
Definition: CAmControlSender.h:120
+
am::IAmControlSend::hookSystemInterruptStateChange
virtual void hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)=0
is called when an low level interrupt changed its state
+
am::CAmSocketHandler::addFDPoll
am_Error_e addFDPoll(const int fd, const short event, IAmShPollPrepare *prepare, IAmShPollFired *fired, IAmShPollCheck *check, IAmShPollDispatch *dispatch, void *userData, sh_pollHandle_t &handle)
Adds a filedescriptor to the polling loop.
Definition: CAmSocketHandler.cpp:195
+
am::IAmControlSend::cbAckSetSourceState
virtual void cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)=0
ack for setting of source states
+
am::IAmControlSend::hookUserSetSinkMuteState
virtual am_Error_e hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)=0
sets the mute state of a sink
+
am::CAmControlSender::hookUserSetMainSinkNotificationConfiguration
am_Error_e hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &notificationConfiguration)
Definition: CAmControlSender.cpp:515
+
am::CAmControlSender::cbAckConnect
void cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
Definition: CAmControlSender.cpp:342
+
am::CAmControlSender::cbAckSetSinkSoundProperty
void cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:395
+
am::IAmControlSend::hookSystemDeregisterSink
virtual am_Error_e hookSystemDeregisterSink(const am_sinkID_t sinkID)=0
is called when a routing adaptor deregisters a sink
+
am::IAmControlSend::cbAckSetVolumes
virtual void cbAckSetVolumes(const am_Handle_s handle, const std::vector< am_Volumes_s > &listVolumes, const am_Error_e error)=0
ack for mulitple volume changes
+
am::am_Handle_s
a handle is used for asynchronous operations and is uniquely assigned for each of this operations ...
Definition: audiomanagertypes.h:991
+
am::IAmControlSend::confirmCommandRundown
virtual void confirmCommandRundown(const am_Error_e error)=0
confirms the setCommandRundown call
+
am::CAmControlSender::hookSystemTimingInformationChanged
void hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
Definition: CAmControlSender.cpp:336
+
am::CAmControlSender::hookSystemRegisterCrossfader
am_Error_e hookSystemRegisterCrossfader(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)
Definition: CAmControlSender.cpp:276
+
am::IAmControlSend::hookSystemReceiveEarlyData
virtual void hookSystemReceiveEarlyData(const std::vector< am_EarlyData_s > &data)=0
when early data was received
+ +
am::am_sourceID_t
uint16_t am_sourceID_t
a source ID
Definition: audiomanagertypes.h:60
+
am::CAmControlSender::hookSystemRegisterGateway
am_Error_e hookSystemRegisterGateway(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)
Definition: CAmControlSender.cpp:252
+
am::IAmControlSend::hookSystemSourceVolumeTick
virtual void hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)=0
volumeticks.
+
am::IAmControlSend::hookSystemTimingInformationChanged
virtual void hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)=0
this hook is fired whenever the timing information of a mainconnection has changed.
+
am::IAmControlSend::hookSystemDeregisterGateway
virtual am_Error_e hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)=0
is called when a routing adaptor deregisters a gateway
+
am::CAmControlSender::cbAckSetSourceState
void cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:372
+
am::CAmControlSender::hookUserSetSinkMuteState
am_Error_e hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
Definition: CAmControlSender.cpp:204
+
am::CAmControlSender
sends data to the commandInterface, takes the file of the library that needs to be loaded ...
Definition: CAmControlSender.h:41
+
am::CAmControlSender::hookUserConnectionRequest
am_Error_e hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t &mainConnectionID)
Definition: CAmControlSender.cpp:162
+
am::IAmControlSend::setControllerRundown
virtual void setControllerRundown(const int16_t signal)=0
This message tells the controller that he should prepare everything for the power to be switched off...
+
am::IAmControlSend::hookSystemDomainRegistrationComplete
virtual void hookSystemDomainRegistrationComplete(const am_domainID_t domainID)=0
is called when a domain registered all the elements
+
am::CAmControlSender::cbAckSetSourceSoundProperty
void cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:378
+
am::IAmControlSend::cbAckSetSourceSoundProperties
virtual void cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)=0
ack for setting of sourcesoundproperties
+
am::CAmControlSender::hookSystemDeregisterDomain
am_Error_e hookSystemDeregisterDomain(const am_domainID_t domainID)
Definition: CAmControlSender.cpp:216
+
am::am_Converter_s
This struct describes the attributes of a converter.
Definition: audiomanagertypes.h:606
+ +
am::IAmControlSend::hookSystemUpdateGateway
virtual am_Error_e hookSystemUpdateGateway(const am_gatewayID_t gatewayID, const std::vector< am_CustomConnectionFormat_t > &listSourceConnectionFormats, const std::vector< am_CustomConnectionFormat_t > &listSinkConnectionFormats, const std::vector< bool > &convertionMatrix)=0
updates the Gateway Data
+
am::IAmControlSend
This interface is presented by the AudioManager controller.
Definition: IAmControl.h:675
+
am::am_Route_s
a list of routing elements that lead from source to sink
Definition: audiomanagertypes.h:810
+
am::IAmControlSend::cbAckDisconnect
virtual void cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)=0
ack for disconnect
+
am::CAmControlSender::hookUserSetMainSourceSoundProperty
am_Error_e hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s &soundProperty)
Definition: CAmControlSender.cpp:180
+
am::am_HotSink_e
am_HotSink_e
describes the active sink of a crossfader.
Definition: audiomanagertypes.h:208
+
am::am_volume_t
int16_t am_volume_t
The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE).
Definition: audiomanagertypes.h:91
+
am::am_Crossfader_s
This struct describes the attribiutes of a crossfader.
Definition: audiomanagertypes.h:560
+
am::IAmControlSend::confirmCommandReady
virtual void confirmCommandReady(const am_Error_e error)=0
confirms the setCommandReady call
+
am::CAmControlSender::hookSystemUpdateSource
am_Error_e hookSystemUpdateSource(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector< am_SoundProperty_s > &listSoundProperties, const std::vector< am_CustomConnectionFormat_t > &listConnectionFormats, const std::vector< am_MainSoundProperty_s > &listMainSoundProperties)
Definition: CAmControlSender.cpp:467
+
am::CAmControlSender::hookSystemSpeedChange
void hookSystemSpeedChange(const am_speed_t speed)
Definition: CAmControlSender.cpp:330
+
am::IAmControlSend::hookUserDisconnectionRequest
virtual am_Error_e hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)=0
is called when a disconnection request comes in via the command interface
+
am::IAmControlSend::hookSystemSinkAvailablityStateChange
virtual void hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s &availability)=0
id called when a sink changed its availability
+
am::CAmControlSender::confirmCommandRundown
void confirmCommandRundown(const am_Error_e error)
Definition: CAmControlSender.cpp:449
+
am::IAmControlSend::hookSystemUpdateConverter
virtual am_Error_e hookSystemUpdateConverter(const am_converterID_t converterID, const std::vector< am_CustomConnectionFormat_t > &listSourceConnectionFormats, const std::vector< am_CustomConnectionFormat_t > &listSinkConnectionFormats, const std::vector< bool > &convertionMatrix)=0
updates the Converter Data
+
am::am_sourceClass_t
uint16_t am_sourceClass_t
Definition: audiomanagertypes.h:102
+
am::IAmControlSend::confirmRoutingRundown
virtual void confirmRoutingRundown(const am_Error_e error)=0
confirms the setRoutingRundown command
+
am::CAmControlSender::cbAckSetVolume
void cbAckSetVolume(const am_Handle_s handle, const std::vector< am_Volumes_s > &listVolumes, const am_Error_e error)
Definition: CAmControlSender.cpp:485
+
am::IAmControlSend::cbAckCrossFade
virtual void cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)=0
ack for crossfading
+
am::CAmControlSender::hookSystemSingleTimingInformationChanged
void hookSystemSingleTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t time)
Definition: CAmControlSender.cpp:542
+
am::am_Availability_s
this describes the availability of a sink or a source together with the latest change ...
Definition: audiomanagertypes.h:523
+
am::am_Gateway_s
This struct describes the attributes of a gateway.
Definition: audiomanagertypes.h:689
+
am::IAmControlReceive
This interface gives access to all important functions of the audiomanager that are used by the Audio...
Definition: IAmControl.h:56
+
am::IAmControlSend::hookSystemDeregisterDomain
virtual am_Error_e hookSystemDeregisterDomain(const am_domainID_t domainID)=0
is called when a routing adaptor wants to derigister a domain
+
am::logError
void logError(T value, TArgs...args)
logs given values with errorlevel with the default context
Definition: CAmDltWrapper.h:416
+
am::IAmControlSend::hookSystemDeregisterConverter
virtual am_Error_e hookSystemDeregisterConverter(const am_converterID_t converterID)=0
is called when a routing adaptor deregisters a converter
+
am::IAmControlSend::hookSystemUpdateSink
virtual am_Error_e hookSystemUpdateSink(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector< am_SoundProperty_s > &listSoundProperties, const std::vector< am_CustomConnectionFormat_t > &listConnectionFormats, const std::vector< am_MainSoundProperty_s > &listMainSoundProperties)=0
update form the SinkData
+
am::IAmControlSend::hookSystemRegisterCrossfader
virtual am_Error_e hookSystemRegisterCrossfader(const am_Crossfader_s &crossfaderData, am_crossfaderID_t &crossfaderID)=0
is called when a routing adaptor registers a crossfader
+
am::IAmControlSend::hookUserConnectionRequest
virtual am_Error_e hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t &mainConnectionID)=0
is called when a connection request comes in via the command interface
+
am::IAmControlSend::cbAckSetSourceVolumeChange
virtual void cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t voulme, const am_Error_e error)=0
ack for source volume changes
+
am::CAmControlSender::hookSystemDeregisterConverter
am_Error_e hookSystemDeregisterConverter(const am_converterID_t converterID)
Definition: CAmControlSender.cpp:270
+
am::IAmControlSend::startupController
virtual am_Error_e startupController(IAmControlReceive *controlreceiveinterface)=0
Starts up the controller.
+
am::CAmControlSender::dispatcherCallbackT
TAmShPollDispatch< CAmControlSender > dispatcherCallbackT
Definition: CAmControlSender.h:122
+
am::IAmControlSend::cbAckSetSinkSoundProperty
virtual void cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)=0
ack for setting of sinksoundproperties
+
am::CAmControlSender::hookSystemDeregisterGateway
am_Error_e hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
Definition: CAmControlSender.cpp:264
+
am::am_speed_t
uint16_t am_speed_t
speed
Definition: audiomanagertypes.h:85
+
am::am_domainID_t
uint16_t am_domainID_t
a domain ID
Definition: audiomanagertypes.h:45
+
am::CAmControlSender::hookSystemSourceVolumeTick
void hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
Definition: CAmControlSender.cpp:294
+
am::am_mainVolume_t
int16_t am_mainVolume_t
This is the volume presented on the command interface.
Definition: audiomanagertypes.h:100
+
am::CAmControlSender::cbAckSetSourceSoundProperties
void cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
Definition: CAmControlSender.cpp:407
+
am::CAmControlSender::hookSystemDeregisterSource
am_Error_e hookSystemDeregisterSource(const am_sourceID_t sourceID)
Definition: CAmControlSender.cpp:246
+
CAmControlSender.h
SPDX license identifier: MPL-2.0.
+
am::IAmControlSend::hookUserSetMainSinkNotificationConfiguration
virtual am_Error_e hookUserSetMainSinkNotificationConfiguration(const am_sinkID_t sinkID, const am_NotificationConfiguration_s &notificationConfiguration)=0
sets a user MainSinkNotificationConfiguration
+
am::IAmControlSend::cbAckSetSourceSoundProperty
virtual void cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)=0
ack for setting of sourcesoundproperties
+
am::CAmControlSender::confirmRoutingRundown
void confirmRoutingRundown(const am_Error_e error)
Definition: CAmControlSender.cpp:455
+
am::IAmControlSend::hookSystemDeregisterSource
virtual am_Error_e hookSystemDeregisterSource(const am_sourceID_t sourceID)=0
is called when a routing adaptor deregisters a source
+
am::am_gatewayID_t
uint16_t am_gatewayID_t
a gateway ID
Definition: audiomanagertypes.h:75
+
am::am_Source_s
This struct describes the attribiutes of a source.
Definition: audiomanagertypes.h:1232
+
am::IAmControlSend::hookSystemSourceAvailablityStateChange
virtual void hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s &availability)=0
id called when a source changed its availability
+
am::am_sinkID_t
uint16_t am_sinkID_t
a sink ID
Definition: audiomanagertypes.h:65
+
am::am_mainConnectionID_t
uint16_t am_mainConnectionID_t
a mainConnection ID
Definition: audiomanagertypes.h:80
+
am::CAmControlSender::cbAckSetSourceVolumeChange
void cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t voulme, const am_Error_e error)
Definition: CAmControlSender.cpp:366
+
am::IAmControlSend::hookSystemRegisterDomain
virtual am_Error_e hookSystemRegisterDomain(const am_Domain_s &domainData, am_domainID_t &domainID)=0
is called when a routing adaptor registers its domain
+
am::IAmControlSend::hookSystemSingleTimingInformationChanged
virtual void hookSystemSingleTimingInformationChanged(const am_connectionID_t connectionID, const am_timeSync_t time)=0
This hook is fired whenever the timing information of a connection has changed.
+
am::CAmControlSender::hookSystemRegisterDomain
am_Error_e hookSystemRegisterDomain(const am_Domain_s &domainData, am_domainID_t &domainID)
Definition: CAmControlSender.cpp:210
+
am::IAmControlSend::hookSystemRegisterSink
virtual am_Error_e hookSystemRegisterSink(const am_Sink_s &sinkData, am_sinkID_t &sinkID)=0
is called when a routing adaptor registers a sink
+
am::IAmControlSend::hookSystemSinkVolumeTick
virtual void hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)=0
volumeticks.
+
am::CAmControlSender::hookUserVolumeStep
am_Error_e hookUserVolumeStep(const am_sinkID_t SinkID, const int16_t increment)
Definition: CAmControlSender.cpp:198
+
am::IAmControlSend::hookSystemRegisterGateway
virtual am_Error_e hookSystemRegisterGateway(const am_Gateway_s &gatewayData, am_gatewayID_t &gatewayID)=0
is called when a routing adaptor registers a gateway
+
am::CAmControlSender::hookSystemReceiveEarlyData
void hookSystemReceiveEarlyData(const std::vector< am_EarlyData_s > &data)
Definition: CAmControlSender.cpp:324
+
am::IAmControlSend::getInterfaceVersion
virtual void getInterfaceVersion(std::string &version) const =0
This function returns the version of the interface returns E_OK, E_UNKOWN if version is unknown...
+
am::IAmControlSend::hookUserSetMainSourceSoundProperty
virtual am_Error_e hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s &soundProperty)=0
sets a user MainSourceSoundProperty
+
+
+ + + + -- cgit v1.2.1