include/control/IAmControlReceive.h

   1 /**\r
   2  * Copyright (C) 2012, GENIVI Alliance, Inc.\r
   3  * Copyright (C) 2012, BMW AG\r
   4  *\r
   5  * This file is part of GENIVI Project AudioManager.\r
   6  *\r
   7  * Contributions are licensed to the GENIVI Alliance under one or more\r
   8  * Contribution License Agreements.\r
   9  *\r
  10  * \copyright\r
  11  * This Source Code Form is subject to the terms of the\r
  12  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with\r
  13  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.\r
  14  *\r
  15  *\r
  16  * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012\r
  17  *\r
  18  * \file CAmCommandReceiver.h\r
  19  * For further information see http://www.genivi.org/.\r
  20  *\r
  21  * THIS CODE HAS BEEN GENERATED BY ENTERPRISE ARCHITECT GENIVI MODEL. PLEASE CHANGE ONLY IN ENTERPRISE ARCHITECT AND GENERATE AGAIN\r
  22  */\r
  23 #if !defined(EA_BB73C4DE_B91D_420d_B810_5DB4F937D21E__INCLUDED_)\r
  24 #define EA_BB73C4DE_B91D_420d_B810_5DB4F937D21E__INCLUDED_\r
  25 \r
  26 #include <vector>\r
  27 #include <string>\r
  28 #include "audiomanagertypes.h"\r
  29 namespace am {\r
  30 class CAmSocketHandler;\r
  31 }\r
  32
  33
  34 #define ControlReceiveVersion "1.0"
  35 namespace am {
  36         /**
  37          * This interface gives access to all important functions of the audiomanager that are used by the AudioManagerController to control the system.\r
  38          * There are two rules that have to be kept in mind when implementing against this interface:\n\r
  39          * \warning\r
  40          * 1. CALLS TO THIS INTERFACE ARE NOT THREAD SAFE !!!! \n\r
  41          * 2. YOU MAY NOT THE CALLING INTERFACE DURING AN SYNCHRONOUS OR ASYNCHRONOUS CALL THAT EXPECTS A RETURN VALUE.\n\r
  42          * \details\r
  43          * Violation these rules may lead to unexpected behavior! Nevertheless you can implement thread safe by using the deferred-call pattern described on the wiki which also helps to implement calls that are forbidden.\n\r
  44          * For more information, please check CAmSerializer
  45          * @author Christian Mueller
  46          * @created 06-Mar-2012 9:46:48 AM
  47          */
  48         class IAmControlReceive
  49         {
  50
  51         public:
  52                 IAmControlReceive() {
  53
  54                 }
  55
  56                 virtual ~IAmControlReceive() {
  57
  58                 }
  59
  60                 /**
  61                  * calculates a route from source to sink.\r
  62                  * @return E_OK on success, E_UNKNOWN on error
  63                  *
  64                  * @param onlyfree    if true return only routes which use gateways that are not in use at the moment
  65                  * @param sourceID
  66                  * @param sinkID
  67                  * @param returnList    this is a list of routes that are possible to take. unsorted! The longest could be first.\r
  68                  * In case not route can be found, the list will return empty.
  69                  */
  70                 virtual am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList) =0;
  71                 /**
  72                  * With this function, elementary connects can be triggered by the controller.\r
  73                  * @return E_OK on success, E_UNKNOWN on error, E_WRONG_FORMAT of connectionFormats do not match, E_NO_CHANGE if the desired connection is already build up
  74                  *
  75                  * @param handle
  76                  * @param connectionID
  77                  * @param format
  78                  * @param sourceID
  79                  * @param sinkID
  80                  */
  81                 virtual am_Error_e connect(am_Handle_s& handle, am_connectionID_t& connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID) =0;
  82                 /**
  83                  * is used to disconnect a connection\r
  84                  * @return E_OK on success, E_UNKNOWN on error, E_NON_EXISTENT if connection was not found, E_NO_CHANGE if no change is neccessary
  85                  *
  86                  * @param handle
  87                  * @param connectionID
  88                  */
  89                 virtual am_Error_e disconnect(am_Handle_s& handle, const am_connectionID_t connectionID) =0;
  90                 /**
  91                  * triggers a cross fade.\r
  92                  * @return E_OK on success, E_UNKNOWN on error E_NO_CHANGE if no change is neccessary
  93                  *
  94                  * @param handle
  95                  * @param hotSource    this is the source that is going to be the active one after the fading
  96                  * @param crossfaderID
  97                  * @param rampType
  98                  * @param rampTime    rampTime 0 means default value
  99                  */
 100                 virtual am_Error_e 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) =0;
 101                 /**
 102                  * with this method, all actions that have a handle assigned can be stopped.\r
 103                  * @return E_OK on success, E_UNKNOWN on error
 104                  *
 105                  * @param handle    the handle of the action to be stopped
 106                  */
 107                 virtual am_Error_e abortAction(const am_Handle_s handle) =0;
 108                 /**
 109                  * this method sets a source state for a source. This function will trigger the callback cbAckSetSourceState\r
 110                  * @return E_OK on success, E_NO_CHANGE if the desired value is already correct, E_UNKNOWN on error, E_NO_CHANGE if no change is neccessary
 111                  *
 112                  * @param handle
 113                  * @param sourceID
 114                  * @param state
 115                  */
 116                 virtual am_Error_e setSourceState(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state) =0;
 117                 /**
 118                  * with this function, setting of sinks volumes is done. The behavior of the volume set is depended on the given ramp and time information.\r
 119                  * This function is not only used to ramp volume, but also to mute and direct set the level. Exact behavior is depended on the selected mute ramps.\r
 120                  * @return E_OK on success, E_NO_CHANGE if the volume is already on the desired value, E_OUT_OF_RANGE is the volume is out of range, E_UNKNOWN on every other error.
 121                  *
 122                  * @param handle
 123                  * @param sinkID
 124                  * @param volume
 125                  * @param ramp
 126                  * @param time
 127                  */
 128                 virtual am_Error_e 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) =0;
 129                 /**
 130                  * with this function, setting of source volumes is done. The behavior of the volume set is depended on the given ramp and time information.\r
 131                  * This function is not only used to ramp volume, but also to mute and direct set the level. Exact behavior is depended on the selected mute ramps.\r
 132                  * @return E_OK on success, E_NO_CHANGE if the volume is already on the desired value, E_OUT_OF_RANGE is the volume is out of range, E_UNKNOWN on every other error.
 133                  *
 134                  * @param handle
 135                  * @param sourceID
 136                  * @param volume
 137                  * @param rampType
 138                  * @param time
 139                  */
 140                 virtual am_Error_e 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) =0;
 141                 /**
 142                  * is used to set several sinkSoundProperties at a time\r
 143                  * @return E_OK on success, E_UNKNOWN on error, E_OUT_OF_RANGE  if property is out of range, E_NO_CHANGE if no change is neccessary
 144                  *
 145                  * @param handle
 146                  * @param sinkID
 147                  * @param soundProperty
 148                  */
 149                 virtual am_Error_e setSinkSoundProperties(am_Handle_s& handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s>& soundProperty) =0;
 150                 /**
 151                  * is used to set sinkSoundProperties\r
 152                  * @return E_OK on success, E_UNKNOWN on error, E_OUT_OF_RANGE  if property is out of range, E_NO_CHANGE if no change is neccessary
 153                  *
 154                  * @param handle
 155                  * @param sinkID
 156                  * @param soundProperty
 157                  */
 158                 virtual am_Error_e setSinkSoundProperty(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s& soundProperty) =0;
 159                 /**
 160                  * is used to set several SourceSoundProperties at a time\r
 161                  * @return E_OK on success, E_UNKNOWN on error, E_OUT_OF_RANGE  if property is out of range. E_NO_CHANGE if no change is neccessary
 162                  *
 163                  * @param handle
 164                  * @param sourceID
 165                  * @param soundProperty
 166                  */
 167                 virtual am_Error_e setSourceSoundProperties(am_Handle_s& handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s>& soundProperty) =0;
 168                 /**
 169                  * is used to set sourceSoundProperties\r
 170                  * @return E_OK on success, E_UNKNOWN on error, E_OUT_OF_RANGE  if property is out of range. E_NO_CHANGE if no change is neccessary
 171                  *
 172                  * @param handle
 173                  * @param sourceID
 174                  * @param soundProperty
 175                  */
 176                 virtual am_Error_e setSourceSoundProperty(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s& soundProperty) =0;
 177                 /**
 178                  * sets the domain state of a domain\r
 179                  * @return E_OK on success, E_UNKNOWN on error, E_NO_CHANGE if no change is neccessary
 180                  *
 181                  * @param domainID
 182                  * @param domainState
 183                  */
 184                 virtual am_Error_e setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState) =0;
 185                 /**
 186                  * enters a domain in the database, creates and ID\r
 187                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 188                  *
 189                  * @param domainData    domainID in am_Domain_s must be 0 here
 190                  * @param domainID
 191                  */
 192                 virtual am_Error_e enterDomainDB(const am_Domain_s& domainData, am_domainID_t& domainID) =0;
 193                 /**
 194                  * enters a mainconnection in the database, creates and ID\r
 195                  * @return E_OK on success, E_DATABASE_ERROR if the database had an error
 196                  *
 197                  * @param mainConnectionData    the MainConnectionID is omitted since it is created during the registration
 198                  * @param connectionID
 199                  */
 200                 virtual am_Error_e enterMainConnectionDB(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID) =0;
 201                 /**
 202                  * enters a sink in the database.\r
 203                  * The sinkID in am_Sink_s shall be 0 in case of a dynamic added source A sinkID greater than 100 will be assigned. If a specific sinkID with a value <100 is given, the given value will be used. This is for a static setup where the ID's are predefined.\r
 204                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 205                  *
 206                  * @param sinkData    the sinkID will be omitted since it is created during the registration
 207                  * @param sinkID
 208                  */
 209                 virtual am_Error_e enterSinkDB(const am_Sink_s& sinkData, am_sinkID_t& sinkID) =0;
 210                 /**
 211                  * enters a crossfader in the database.\r
 212                  * The crossfaderID in am_Crossfader_s shall be 0 in case of a dynamic added source A crossfaderID greater than 100 will be assigned. If a specific crossfaderID with a value <100 is given, the given value will be used. This is for a static setup where the ID's are predefined.\r
 213                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 214                  *
 215                  * @param crossfaderData    the ID in the data will be ignored since it is created during the registration
 216                  * @param crossfaderID
 217                  */
 218                 virtual am_Error_e enterCrossfaderDB(const am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID) =0;
 219                 /**
 220                  * enters a gateway in the database.\r
 221                  * The gatewayID in am_Gateway_s shall be 0 in case of a dynamic added source A gatewayID greater than 100 will be assigned. If a specific gatewayID with a value <100 is given, the given value will be used. This is for a static setup where the ID's are predefined.\r
 222                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 223                  *
 224                  * @param gatewayData    In a fixed setup, the gatewayID must be below 100. In a dynamic setup, the gatewayID shall be 0! listSourceFormats and listSinkFormats are empty at registration time. Values are taken over when sources and sinks are registered.
 225                  * @param gatewayID
 226                  */
 227                 virtual am_Error_e enterGatewayDB(const am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID) =0;
 228                 /**
 229                  * enters a source in the database.\r
 230                  * The sourceID in am_Source_s shall be 0 in case of a dynamic added source A sourceID greater than 100 will be assigned. If a specific sourceID with a value <100 is given, the given value will be used. This is for a static setup where the ID's are predefined.\r
 231                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 232                  *
 233                  * @param sourceData    sourceID is omitted here since it is created during registration
 234                  * @param sourceID
 235                  */
 236                 virtual am_Error_e enterSourceDB(const am_Source_s& sourceData, am_sourceID_t& sourceID) =0;
 237                 /**
 238                  * Enters a sourceClass into the database.\r
 239                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 240                  *
 241                  * @param sinkClass    IDs given with the SinkCLassID are valid below 100 (static). If given as 0, sinkClass will be enterd dynamic and ID above 100 will be created.
 242                  * @param sinkClassID
 243                  */
 244                 virtual am_Error_e enterSinkClassDB(const am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID) =0;
 245                 /**
 246                  * Enters a sourceClass into the database.\r
 247                  * The sourceClassID in am_sourceClass_s shall be 0 in case of a dynamic added source A sourceClassID greater than 100 will be assigned. If a specific sourceClassID with a value <100 is given, the given value will be used. This is for a static setup where the ID's are predefined.\r
 248                  * @return E_OK on success, E_ALREADY_EXISTENT if the ID or name is already in the database, E_DATABASE_ERROR if the database had an error
 249                  *
 250                  * @param sourceClassID
 251                  * @param sourceClass    IDs given with the SourceCLassID are valid below 100 (static). If given as 0, sourceClass will be enterd dynamic and ID above 100 will be created.
 252                  */
 253                 virtual am_Error_e enterSourceClassDB(am_sourceClass_t& sourceClassID, const am_SourceClass_s& sourceClass) =0;
 254                 /**
 255                  * changes class information of a sinkclass.\r
 256                  * The properties will overwrite the values of the sinkClassID given in the sinkClass.\r
 257                  * It is the duty of the controller to check if the property is valid. If it does not exist, the daemon will not return an error.\r
 258                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sinkClassID was not found.
 259                  *
 260                  * @param sinkClass    if a SourceClass ID other than 0 is given, the classInformation replaces the existing one. In case of ClassID 0, a new classID is created and returned
 261                  */
 262                 virtual am_Error_e changeSinkClassInfoDB(const am_SinkClass_s& sinkClass) =0;
 263                 /**
 264                  * changes class information of a sourceClass. \r
 265                  * The properties will overwrite the values of the sourceClassID given in the sourceClass.\r
 266                  * It is the duty of the controller to check if the property is valid. If it does not exist, the daemon will not return an error.\r
 267                  * @return E_OK on success, E_DATABASE_ERROR on error and E_NON_EXISTENT if the ClassID does not exist.
 268                  *
 269                  * @param sourceClass    if a SourceClass ID other than 0 is given, the classInformation replaces the existing one. In case of ClassID 0, a new classID is created and returned
 270                  */
 271                 virtual am_Error_e changeSourceClassInfoDB(const am_SourceClass_s& sourceClass) =0;
 272                 /**
 273                  * This function is used to enter the system Properties into the database.\r
 274                  * All entries in the database will be erased before entering the new List. It should only be called once at system startup.\r
 275                  * @return E_OK on success,  E_DATABASE_ERROR if the database had an error
 276                  *
 277                  * @param listSystemProperties
 278                  */
 279                 virtual am_Error_e enterSystemPropertiesListDB(const std::vector<am_SystemProperty_s>& listSystemProperties) =0;
 280                 /**
 281                  * changes the mainConnectionState of MainConnection\r
 282                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if mainconnection
 283                  *
 284                  * @param mainconnectionID
 285                  * @param listConnectionID
 286                  */
 287                 virtual am_Error_e changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID) =0;
 288                 /**
 289                  * changes the mainConnectionState of MainConnection\r
 290                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if mainconnection
 291                  *
 292                  * @param mainconnectionID
 293                  * @param connectionState
 294                  */
 295                 virtual am_Error_e changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState) =0;
 296                 /**
 297                  * changes the sink volume of a sink\r
 298                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 299                  *
 300                  * @param mainVolume
 301                  * @param sinkID
 302                  */
 303                 virtual am_Error_e changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID) =0;
 304                 /**
 305                  * changes the availablility of a sink\r
 306                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 307                  *
 308                  * @param availability
 309                  * @param sinkID
 310                  */
 311                 virtual am_Error_e changeSinkAvailabilityDB(const am_Availability_s& availability, const am_sinkID_t sinkID) =0;
 312                 /**
 313                  * changes the domainstate of a domain \r
 314                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if domain was not found
 315                  *
 316                  * @param domainState
 317                  * @param domainID
 318                  */
 319                 virtual am_Error_e changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID) =0;
 320                 /**
 321                  * changes the mute state of a sink\r
 322                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 323                  *
 324                  * @param muteState
 325                  * @param sinkID
 326                  */
 327                 virtual am_Error_e changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID) =0;
 328                 /**
 329                  * changes the mainsinksoundproperty of a sink\r
 330                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 331                  *
 332                  * @param soundProperty
 333                  * @param sinkID
 334                  */
 335                 virtual am_Error_e changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID) =0;
 336                 /**
 337                  * changes the mainsourcesoundproperty of a sink\r
 338                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if source was not found
 339                  *
 340                  * @param soundProperty
 341                  * @param sourceID
 342                  */
 343                 virtual am_Error_e changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID) =0;
 344                 /**
 345                  * changes the availablility of a source\r
 346                  * @return E_OK on success, E_DATABASE_ERROR  on error, E_NON_EXISTENT if source was not found
 347                  *
 348                  * @param availability
 349                  * @param sourceID
 350                  */
 351                 virtual am_Error_e changeSourceAvailabilityDB(const am_Availability_s& availability, const am_sourceID_t sourceID) =0;
 352                 /**
 353                  * changes a systemProperty\r
 354                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if property was not found
 355                  *
 356                  * @param property
 357                  */
 358                 virtual am_Error_e changeSystemPropertyDB(const am_SystemProperty_s& property) =0;
 359                 /**
 360                  * removes a mainconnection from the DB\r
 361                  * @return E_OK on success, E_NON_EXISTENT if main connection was not found, E_DATABASE_ERROR if the database had an error
 362                  *
 363                  * @param mainConnectionID
 364                  */
 365                 virtual am_Error_e removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID) =0;
 366                 /**
 367                  * removes a sink from the DB\r
 368                  * @return E_OK on success, E_NON_EXISTENT if sink was not found, E_DATABASE_ERROR if the database had an error
 369                  *
 370                  * @param sinkID
 371                  */
 372                 virtual am_Error_e removeSinkDB(const am_sinkID_t sinkID) =0;
 373                 /**
 374                  * removes a source from the DB\r
 375                  * @return E_OK on success, E_NON_EXISTENT if source was not found, E_DATABASE_ERROR if the database had an error
 376                  *
 377                  * @param sourceID
 378                  */
 379                 virtual am_Error_e removeSourceDB(const am_sourceID_t sourceID) =0;
 380                 /**
 381                  * removes a gateway from the DB\r
 382                  * @return E_OK on success, E_NON_EXISTENT if gateway was not found, E_DATABASE_ERROR if the database had an error
 383                  *
 384                  * @param gatewayID
 385                  */
 386                 virtual am_Error_e removeGatewayDB(const am_gatewayID_t gatewayID) =0;
 387                 /**
 388                  * removes a crossfader from the DB\r
 389                  * @return E_OK on success, E_NON_EXISTENT if crossfader was not found, E_DATABASE_ERROR if the database had an error
 390                  *
 391                  * @param crossfaderID
 392                  */
 393                 virtual am_Error_e removeCrossfaderDB(const am_crossfaderID_t crossfaderID) =0;
 394                 /**
 395                  * removes a domain from the DB\r
 396                  * @return E_OK on success, E_NON_EXISTENT if domain was not found, E_DATABASE_ERROR if the database had an error
 397                  *
 398                  * @param domainID
 399                  */
 400                 virtual am_Error_e removeDomainDB(const am_domainID_t domainID) =0;
 401                 /**
 402                  * removes a domain from the DB\r
 403                  * @return E_OK on success, E_NON_EXISTENT if domain was not found, E_DATABASE_ERROR if the database had an error
 404                  *
 405                  * @param sinkClassID
 406                  */
 407                 virtual am_Error_e removeSinkClassDB(const am_sinkClass_t sinkClassID) =0;
 408                 /**
 409                  * removes a domain from the DB\r
 410                  * @return E_OK on success, E_NON_EXISTENT if domain was not found, E_DATABASE_ERROR if the database had an error
 411                  *
 412                  * @param sourceClassID
 413                  */
 414                 virtual am_Error_e removeSourceClassDB(const am_sourceClass_t sourceClassID) =0;
 415                 /**
 416                  * returns the ClassInformation of a source\r
 417                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if source was not found
 418                  *
 419                  * @param sourceID
 420                  * @param classInfo
 421                  */
 422                 virtual am_Error_e getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s& classInfo) const =0;
 423                 /**
 424                  * returns the ClassInformation of a sink\r
 425                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 426                  *
 427                  * @param sinkID
 428                  * @param sinkClass
 429                  */
 430                 virtual am_Error_e getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s& sinkClass) const =0;
 431                 /**
 432                  * returns the sinkData of a sink\r
 433                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 434                  *
 435                  * @param sinkID
 436                  * @param sinkData
 437                  */
 438                 virtual am_Error_e getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s& sinkData) const =0;
 439                 /**
 440                  * returns the sourcekData of a source\r
 441                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if sink was not found
 442                  *
 443                  * @param sourceID
 444                  * @param sourceData
 445                  */
 446                 virtual am_Error_e getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s& sourceData) const =0;
 447                 /**
 448                  * return source and sink of a gateway\r
 449                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if gateway was not found
 450                  *
 451                  * @param gatewayID
 452                  * @param gatewayData
 453                  */
 454                 virtual am_Error_e getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s& gatewayData) const =0;
 455                 /**
 456                  * returns sources and the sink of a crossfader\r
 457                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if crossfader was not found
 458                  *
 459                  * @param crossfaderID
 460                  * @param crossfaderData
 461                  */
 462                 virtual am_Error_e getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData) const =0;
 463                 /**
 464                  * returns sources and the sink of a crossfader\r
 465                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if crossfader was not found
 466                  *
 467                  * @param mainConnectionID
 468                  * @param mainConnectionData
 469                  */
 470                 virtual am_Error_e getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData) const =0;
 471                 /**
 472                  * returns all sinks of a domain\r
 473                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if domain was not found
 474                  *
 475                  * @param domainID
 476                  * @param listSinkID
 477                  */
 478                 virtual am_Error_e getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID) const =0;
 479                 /**
 480                  * returns all source of a domain\r
 481                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if domain was not found
 482                  *
 483                  * @param domainID
 484                  * @param listSourceID
 485                  */
 486                 virtual am_Error_e getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID) const =0;
 487                 /**
 488                  * returns all crossfaders of a domain\r
 489                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if domain was not found
 490                  *
 491                  * @param domainID
 492                  * @param listCrossfadersID
 493                  */
 494                 virtual am_Error_e getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t>& listCrossfadersID) const =0;
 495                 /**
 496                  * returns all gateways of a domain\r
 497                  * @return E_OK on success, E_DATABASE_ERROR on error, E_NON_EXISTENT if domain was not found
 498                  *
 499                  * @param domainID
 500                  * @param listGatewaysID
 501                  */
 502                 virtual am_Error_e getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID) const =0;
 503                 /**
 504                  * returns a complete list of all MainConnections\r
 505                  * @return E_OK on success, E_DATABASE_ERROR on error
 506                  *
 507                  * @param listMainConnections
 508                  */
 509                 virtual am_Error_e getListMainConnections(std::vector<am_MainConnection_s>& listMainConnections) const =0;
 510                 /**
 511                  * returns a complete list of all domains\r
 512                  * @return E_OK on success, E_DATABASE_ERROR on error
 513                  *
 514                  * @param listDomains
 515                  */
 516                 virtual am_Error_e getListDomains(std::vector<am_Domain_s>& listDomains) const =0;
 517                 /**
 518                  * returns a complete list of all Connections\r
 519                  * @return E_OK on success, E_DATABASE_ERROR on error
 520                  *
 521                  * @param listConnections
 522                  */
 523                 virtual am_Error_e getListConnections(std::vector<am_Connection_s>& listConnections) const =0;
 524                 /**
 525                  * returns a list of all sinks\r
 526                  * @return E_OK on success, E_DATABASE_ERROR on error
 527                  *
 528                  * @param listSinks
 529                  */
 530                 virtual am_Error_e getListSinks(std::vector<am_Sink_s>& listSinks) const =0;
 531                 /**
 532                  * returns a list of all sources\r
 533                  * @return E_OK on success, E_DATABASE_ERROR on error
 534                  *
 535                  * @param listSources
 536                  */
 537                 virtual am_Error_e getListSources(std::vector<am_Source_s>& listSources) const =0;
 538                 /**
 539                  * returns a list of all source classes\r
 540                  * @return E_OK on success, E_DATABASE_ERROR on error
 541                  *
 542                  * @param listSourceClasses
 543                  */
 544                 virtual am_Error_e getListSourceClasses(std::vector<am_SourceClass_s>& listSourceClasses) const =0;
 545                 /**
 546                  * returns a list of all handles\r
 547                  * @return E_OK on success, E_DATABASE_ERROR on error
 548                  *
 549                  * @param listHandles
 550                  */
 551                 virtual am_Error_e getListHandles(std::vector<am_Handle_s>& listHandles) const =0;
 552                 /**
 553                  * returns a list of all crossfaders\r
 554                  * @return E_OK on success, E_DATABASE_ERROR on error
 555                  *
 556                  * @param listCrossfaders
 557                  */
 558                 virtual am_Error_e getListCrossfaders(std::vector<am_Crossfader_s>& listCrossfaders) const =0;
 559                 /**
 560                  * returns a list of  gateways\r
 561                  * @return E_OK on success, E_DATABASE_ERROR on error
 562                  *
 563                  * @param listGateways
 564                  */
 565                 virtual am_Error_e getListGateways(std::vector<am_Gateway_s>& listGateways) const =0;
 566                 /**
 567                  * returns a list of all sink classes\r
 568                  * @return E_OK on success, E_DATABASE_ERROR on error
 569                  *
 570                  * @param listSinkClasses
 571                  */
 572                 virtual am_Error_e getListSinkClasses(std::vector<am_SinkClass_s>& listSinkClasses) const =0;
 573                 /**
 574                  * returns the list of SystemProperties
 575                  *
 576                  * @param listSystemProperties
 577                  */
 578                 virtual am_Error_e getListSystemProperties(std::vector<am_SystemProperty_s>& listSystemProperties) const =0;
 579                 /**
 580                  * sets the command interface to ready. Will send setCommandReady to each of the plugins. The corresponding answer is confirmCommandReady.
 581                  */
 582                 virtual void setCommandReady() =0;
 583                 /**
 584                  * sets the command interface into the rundown state. Will send setCommandRundown to each of the plugins. The corresponding answer is confirmCommandRundown.
 585                  */
 586                 virtual void setCommandRundown() =0;
 587                 /**
 588                  * sets the routinginterface to  ready. Will send the command  setRoutingReady to each of the plugins. The related answer is confirmRoutingReady.
 589                  */
 590                 virtual void setRoutingReady() =0;
 591                 /**
 592                  * sets the routinginterface to the rundown state. Will send the command  setRoutingRundown to each of the plugins. The related answer is confirmRoutingRundown.
 593                  */
 594                 virtual void setRoutingRundown() =0;
 595                 /**
 596                  * acknowledges the setControllerReady call.
 597                  */
 598                 virtual void confirmControllerReady() =0;
 599                 /**
 600                  * acknowledges the setControllerRundown call.
 601                  */
 602                 virtual void confirmControllerRundown() =0;
 603                 /**
 604                  * This function returns the pointer to the socketHandler. This can be used to integrate socket-based activites like communication with the mainloop of the AudioManager.\r
 605                  * returns E_OK if pointer is valid, E_UNKNOWN in case AudioManager was compiled without socketHandler support,
 606                  *
 607                  * @param socketHandler
 608                  */
 609                 virtual am_Error_e getSocketHandler(CAmSocketHandler*& socketHandler) =0;
 610                 /**
 611                  * This function returns the version of the interface
 612                  *
 613                  * @param version
 614                  */
 615                 virtual void getInterfaceVersion(std::string& version) const =0;
 616
 617         };
 618 }
 619 #endif // !defined(EA_BB73C4DE_B91D_420d_B810_5DB4F937D21E__INCLUDED_)