include/command/IAmCommandSend.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_0E8D4103_1F90_467a_8935_61E9B1448750__INCLUDED_)\r
  24 #define EA_0E8D4103_1F90_467a_8935_61E9B1448750__INCLUDED_\r
  25 \r
  26 #include <vector>\r
  27 #include <string>\r
  28 #include "audiomanagertypes.h"\r
  29 \r
  30 namespace am {\r
  31 class IAmCommandReceive;\r
  32 }
  33
  34 #include "IAmCommandReceive.h"
  35
  36 #define CommandSendVersion "1.0"
  37 namespace am {
  38         /**
  39          * This interface handles all communication from the AudioManagerDaemon towards the system. It is designed in such a way that only callbacks with no return types are implemented. So when the CommandInterfacePlugins are designed in such a way that they broadcast signals to any node who is interested in the particular information (like signals on Dbus for example), more information can be retrieved via the CommandReceiveInterface.\r
  40          * There are two rules that have to be kept in mind when implementing against this interface:\n\r
  41          * \warning\r
  42          * 1. CALLS TO THIS INTERFACE ARE NOT THREAD SAFE !!!! \n\r
  43          * 2. YOU MAY NOT THE CALLING INTERFACE DURING AN SYNCHRONOUS OR ASYNCHRONOUS CALL THAT EXPECTS A RETURN VALUE.\n\r
  44          * \details\r
  45          * 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
  46          * For more information, please check CAmSerializer
  47          * @author Christian Mueller
  48          * @created 06-Mar-2012 9:46:48 AM
  49          */
  50         class IAmCommandSend
  51         {
  52
  53         public:
  54                 IAmCommandSend() {
  55
  56                 }
  57
  58                 virtual ~IAmCommandSend() {
  59
  60                 }
  61
  62                 /**
  63                  * This command starts the interface, the plugin itself. This is not meant to start communication with the HMI itself. It is a good idea to implement here everything that sets up the basic communication like DbusCommunication etc...\r
  64                  * Be aware of side effects with systemd and socketbased communication!\r
  65                  * @return E_OK on success, E_UNKNOWN on error
  66                  *
  67                  * @param commandreceiveinterface    pointer to the receive interface. Is used to call the audiomanagerdaemon
  68                  */
  69                 virtual am_Error_e startupInterface(IAmCommandReceive* commandreceiveinterface) =0;
  70                 /**
  71                  * This function will indirectly be called by the Controller and is used to start the Communication. Before this command, all communication will be ignored by the AudioManager.\r
  72                  * After the Plugin is ready, it will asynchronously answer with condfirmCommandReady, the handle that is handed over must be returned.
  73                  *
  74                  * @param handle    the handle uniquely idenfies the request
  75                  */
  76                 virtual void setCommandReady(const uint16_t handle) =0;
  77                 /**
  78                  * This function will indirectly be called by the Controller and is used to stop the Communication. After this command, all communication will be ignored by the AudioManager. The plugin has to be prepared that either the power will be switched off or the Interface is started again with setCommandReady\r
  79                  * After the Plugin is ready to rundown, it will asynchronously answer with condfirmCommandRundown, the handle that is handed over must be returned.
  80                  *
  81                  * @param handle    This handle uniquly idenfies the request
  82                  */
  83                 virtual void setCommandRundown(const uint16_t handle) =0;
  84                 /**
  85                  * Callback that is called when the number of connections change
  86                  *
  87                  * @param mainConnection
  88                  */
  89                 virtual void cbNewMainConnection(const am_MainConnectionType_s mainConnection) =0;
  90                 /**
  91                  * Callback that is called when the number of connections change
  92                  *
  93                  * @param mainConnection
  94                  */
  95                 virtual void cbRemovedMainConnection(const am_mainConnectionID_t mainConnection) =0;
  96                 /**
  97                  * Callback that is called when the number of sinks change
  98                  *
  99                  * @param sink
 100                  */
 101                 virtual void cbNewSink(const am_SinkType_s& sink) =0;
 102                 /**
 103                  * Callback that is called when the number of sinks change
 104                  *
 105                  * @param sinkID
 106                  */
 107                 virtual void cbRemovedSink(const am_sinkID_t sinkID) =0;
 108                 /**
 109                  * Callback that is called when the number of sources change
 110                  *
 111                  * @param source
 112                  */
 113                 virtual void cbNewSource(const am_SourceType_s& source) =0;
 114                 /**
 115                  * Callback that is called when the number of sources change
 116                  *
 117                  * @param source
 118                  */
 119                 virtual void cbRemovedSource(const am_sourceID_t source) =0;
 120                 /**
 121                  * this callback is fired if the number of sink classes changed
 122                  */
 123                 virtual void cbNumberOfSinkClassesChanged() =0;
 124                 /**
 125                  * this callback is fired if the number of source classes changed
 126                  */
 127                 virtual void cbNumberOfSourceClassesChanged() =0;
 128                 /**
 129                  * This callback is called when the ConnectionState of a connection changed.
 130                  *
 131                  * @param connectionID
 132                  * @param connectionState
 133                  */
 134                 virtual void cbMainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState) =0;
 135                 /**
 136                  * this callback indicates that a sinkSoundProperty has changed.
 137                  *
 138                  * @param sinkID
 139                  * @param soundProperty
 140                  */
 141                 virtual void cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& soundProperty) =0;
 142                 /**
 143                  * this callback indicates that a sourceSoundProperty has changed.
 144                  *
 145                  * @param sourceID
 146                  * @param soundProperty
 147                  */
 148                 virtual void cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& soundProperty) =0;
 149                 /**
 150                  * this callback is called when the availability of a sink has changed
 151                  *
 152                  * @param sinkID
 153                  * @param availability
 154                  */
 155                 virtual void cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s& availability) =0;
 156                 /**
 157                  * this callback is called when the availability of source has changed.
 158                  *
 159                  * @param sourceID
 160                  * @param availability
 161                  */
 162                 virtual void cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s& availability) =0;
 163                 /**
 164                  * this callback indicates a volume change on the indicated sink
 165                  *
 166                  * @param sinkID
 167                  * @param volume
 168                  */
 169                 virtual void cbVolumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume) =0;
 170                 /**
 171                  * this callback indicates a mute state change on a sink.
 172                  *
 173                  * @param sinkID
 174                  * @param muteState
 175                  */
 176                 virtual void cbSinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState) =0;
 177                 /**
 178                  * is fired if a systemProperty changed
 179                  *
 180                  * @param systemProperty
 181                  */
 182                 virtual void cbSystemPropertyChanged(const am_SystemProperty_s& systemProperty) =0;
 183                 /**
 184                  * This callback is fired if the timinginformation for a mainConnectionID changed
 185                  *
 186                  * @param mainConnectionID
 187                  * @param time
 188                  */
 189                 virtual void cbTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time) =0;
 190                 /**
 191                  * returns the interface version as string.
 192                  *
 193                  * @param version
 194                  */
 195                 virtual void getInterfaceVersion(std::string& version) const =0;
 196
 197         };
 198 }
 199 #endif // !defined(EA_0E8D4103_1F90_467a_8935_61E9B1448750__INCLUDED_)