diff options
Diffstat (limited to 'PluginCommandInterfaceCAPI/src-gen/org/genivi')
12 files changed, 8922 insertions, 0 deletions
diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp new file mode 100644 index 0000000..8092420 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.cpp @@ -0,0 +1,1043 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * @author Christian Linke + */ +#include "am.h" + + +namespace org { +namespace genivi { +namespace am { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +am_Route_s::am_Route_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_RoutingElement_L& routeValue): + sourceID(sourceIDValue), + sinkID(sinkIDValue), + route(routeValue) +{ +} + + +bool operator==(const am_Route_s& lhs, const am_Route_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.route == rhs.route + ; +} + +void am_Route_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> route; +} + +void am_Route_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << sinkID; + outputStream << route; +} + +am_Availability_s::am_Availability_s(const am_Availability_e& availabilityValue, const am_CustomAvailabilityReason_t& availabilityReasonValue): + availability(availabilityValue), + availabilityReason(availabilityReasonValue) +{ +} + + +bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.availability == rhs.availability && + lhs.availabilityReason == rhs.availabilityReason + ; +} + +void am_Availability_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> availability; + inputStream >> availabilityReason; +} + +void am_Availability_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << availability; + outputStream << availabilityReason; +} + +am_ClassProperty_s::am_ClassProperty_s(const am_CustomClassProperty_t& classPropertyValue, const int16_t& valueValue): + classProperty(classPropertyValue), + value(valueValue) +{ +} + + +bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.classProperty == rhs.classProperty && + lhs.value == rhs.value + ; +} + +void am_ClassProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> classProperty; + inputStream >> value; +} + +void am_ClassProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << classProperty; + outputStream << value; +} + +am_Crossfader_s::am_Crossfader_s(const am_crossfaderID_t& crossfaderIDValue, const std::string& nameValue, const am_sinkID_t& sinkID_AValue, const am_sinkID_t& sinkID_BValue, const am_sourceID_t& sourceIDValue, const am_HotSink_e& hotSinkValue): + crossfaderID(crossfaderIDValue), + name(nameValue), + sinkID_A(sinkID_AValue), + sinkID_B(sinkID_BValue), + sourceID(sourceIDValue), + hotSink(hotSinkValue) +{ +} + + +bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.crossfaderID == rhs.crossfaderID && + lhs.name == rhs.name && + lhs.sinkID_A == rhs.sinkID_A && + lhs.sinkID_B == rhs.sinkID_B && + lhs.sourceID == rhs.sourceID && + lhs.hotSink == rhs.hotSink + ; +} + +void am_Crossfader_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> crossfaderID; + inputStream >> name; + inputStream >> sinkID_A; + inputStream >> sinkID_B; + inputStream >> sourceID; + inputStream >> hotSink; +} + +void am_Crossfader_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << crossfaderID; + outputStream << name; + outputStream << sinkID_A; + outputStream << sinkID_B; + outputStream << sourceID; + outputStream << hotSink; +} + +am_Gateway_s::am_Gateway_s(const am_gatewayID_t& gatewayIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainSinkIDValue, const am_domainID_t& domainSourceIDValue, const am_domainID_t& controlDomainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue): + gatewayID(gatewayIDValue), + name(nameValue), + sinkID(sinkIDValue), + sourceID(sourceIDValue), + domainSinkID(domainSinkIDValue), + domainSourceID(domainSourceIDValue), + controlDomainID(controlDomainIDValue), + listSourceFormats(listSourceFormatsValue), + listSinkFormats(listSinkFormatsValue), + convertionMatrix(convertionMatrixValue) +{ +} + + +bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.gatewayID == rhs.gatewayID && + lhs.name == rhs.name && + lhs.sinkID == rhs.sinkID && + lhs.sourceID == rhs.sourceID && + lhs.domainSinkID == rhs.domainSinkID && + lhs.domainSourceID == rhs.domainSourceID && + lhs.controlDomainID == rhs.controlDomainID && + lhs.listSourceFormats == rhs.listSourceFormats && + lhs.listSinkFormats == rhs.listSinkFormats && + lhs.convertionMatrix == rhs.convertionMatrix + ; +} + +void am_Gateway_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> gatewayID; + inputStream >> name; + inputStream >> sinkID; + inputStream >> sourceID; + inputStream >> domainSinkID; + inputStream >> domainSourceID; + inputStream >> controlDomainID; + inputStream >> listSourceFormats; + inputStream >> listSinkFormats; + inputStream >> convertionMatrix; +} + +void am_Gateway_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << gatewayID; + outputStream << name; + outputStream << sinkID; + outputStream << sourceID; + outputStream << domainSinkID; + outputStream << domainSourceID; + outputStream << controlDomainID; + outputStream << listSourceFormats; + outputStream << listSinkFormats; + outputStream << convertionMatrix; +} + +am_Converter_s::am_Converter_s(const am_converterID_t& converterIDValue, const std::string& nameValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const am_ConnectionFormat_L& listSourceFormatsValue, const am_ConnectionFormat_L& listSinkFormatsValue, const am_Convertion_L& convertionMatrixValue): + converterID(converterIDValue), + name(nameValue), + sinkID(sinkIDValue), + sourceID(sourceIDValue), + domainID(domainIDValue), + listSourceFormats(listSourceFormatsValue), + listSinkFormats(listSinkFormatsValue), + convertionMatrix(convertionMatrixValue) +{ +} + + +bool operator==(const am_Converter_s& lhs, const am_Converter_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.converterID == rhs.converterID && + lhs.name == rhs.name && + lhs.sinkID == rhs.sinkID && + lhs.sourceID == rhs.sourceID && + lhs.domainID == rhs.domainID && + lhs.listSourceFormats == rhs.listSourceFormats && + lhs.listSinkFormats == rhs.listSinkFormats && + lhs.convertionMatrix == rhs.convertionMatrix + ; +} + +void am_Converter_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> converterID; + inputStream >> name; + inputStream >> sinkID; + inputStream >> sourceID; + inputStream >> domainID; + inputStream >> listSourceFormats; + inputStream >> listSinkFormats; + inputStream >> convertionMatrix; +} + +void am_Converter_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << converterID; + outputStream << name; + outputStream << sinkID; + outputStream << sourceID; + outputStream << domainID; + outputStream << listSourceFormats; + outputStream << listSinkFormats; + outputStream << convertionMatrix; +} + +am_RoutingElement_s::am_RoutingElement_s(const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_domainID_t& domainIDValue, const am_CustomConnectionFormat_t& connectionFormatValue): + sourceID(sourceIDValue), + sinkID(sinkIDValue), + domainID(domainIDValue), + connectionFormat(connectionFormatValue) +{ +} + + +bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.domainID == rhs.domainID && + lhs.connectionFormat == rhs.connectionFormat + ; +} + +void am_RoutingElement_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> domainID; + inputStream >> connectionFormat; +} + +void am_RoutingElement_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << sinkID; + outputStream << domainID; + outputStream << connectionFormat; +} + +am_SoundProperty_s::am_SoundProperty_s(const am_CustomSoundPropertyType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_SoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_SoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_SystemProperty_s::am_SystemProperty_s(const am_CustomSystemPropertyType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_SystemProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_SystemProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_SinkClass_s::am_SinkClass_s(const am_sinkClass_t& sinkClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue): + sinkClassID(sinkClassIDValue), + name(nameValue), + listClassProperties(listClassPropertiesValue) +{ +} + + +bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sinkClassID == rhs.sinkClassID && + lhs.name == rhs.name && + lhs.listClassProperties == rhs.listClassProperties + ; +} + +void am_SinkClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sinkClassID; + inputStream >> name; + inputStream >> listClassProperties; +} + +void am_SinkClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sinkClassID; + outputStream << name; + outputStream << listClassProperties; +} + +am_SourceClass_s::am_SourceClass_s(const am_sourceClass_t& sourceClassIDValue, const std::string& nameValue, const am_ClassProperty_L& listClassPropertiesValue): + sourceClassID(sourceClassIDValue), + name(nameValue), + listClassProperties(listClassPropertiesValue) +{ +} + + +bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceClassID == rhs.sourceClassID && + lhs.name == rhs.name && + lhs.listClassProperties == rhs.listClassProperties + ; +} + +void am_SourceClass_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceClassID; + inputStream >> name; + inputStream >> listClassProperties; +} + +void am_SourceClass_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceClassID; + outputStream << name; + outputStream << listClassProperties; +} + +am_SourceType_s::am_SourceType_s(const am_sourceID_t& sourceIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_sourceClass_t& sourceClassIDValue): + sourceID(sourceIDValue), + name(nameValue), + availability(availabilityValue), + sourceClassID(sourceClassIDValue) +{ +} + + +bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.name == rhs.name && + lhs.availability == rhs.availability && + lhs.sourceClassID == rhs.sourceClassID + ; +} + +void am_SourceType_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> name; + inputStream >> availability; + inputStream >> sourceClassID; +} + +void am_SourceType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << name; + outputStream << availability; + outputStream << sourceClassID; +} + +am_SinkType_s::am_SinkType_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_Availability_s& availabilityValue, const am_mainVolume_t& volumeValue, const am_MuteState_e& muteStateValue, const am_sinkClass_t& sinkClassIDValue): + sinkID(sinkIDValue), + name(nameValue), + availability(availabilityValue), + volume(volumeValue), + muteState(muteStateValue), + sinkClassID(sinkClassIDValue) +{ +} + + +bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sinkID == rhs.sinkID && + lhs.name == rhs.name && + lhs.availability == rhs.availability && + lhs.volume == rhs.volume && + lhs.muteState == rhs.muteState && + lhs.sinkClassID == rhs.sinkClassID + ; +} + +void am_SinkType_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sinkID; + inputStream >> name; + inputStream >> availability; + inputStream >> volume; + inputStream >> muteState; + inputStream >> sinkClassID; +} + +void am_SinkType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sinkID; + outputStream << name; + outputStream << availability; + outputStream << volume; + outputStream << muteState; + outputStream << sinkClassID; +} + +am_Handle_s::am_Handle_s(const am_Handle_e& handleTypeValue, const uint16_t& handleValue): + handleType(handleTypeValue), + handle(handleValue) +{ +} + + +bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.handleType == rhs.handleType && + lhs.handle == rhs.handle + ; +} + +void am_Handle_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> handleType; + inputStream >> handle; +} + +void am_Handle_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << handleType; + outputStream << handle; +} + +am_MainSoundProperty_s::am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_MainSoundProperty_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_MainSoundProperty_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_MainConnectionType_s::am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_ConnectionState_e& connectionStateValue): + mainConnectionID(mainConnectionIDValue), + sourceID(sourceIDValue), + sinkID(sinkIDValue), + delay(delayValue), + connectionState(connectionStateValue) +{ +} + + +bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.mainConnectionID == rhs.mainConnectionID && + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.delay == rhs.delay && + lhs.connectionState == rhs.connectionState + ; +} + +void am_MainConnectionType_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> mainConnectionID; + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> delay; + inputStream >> connectionState; +} + +void am_MainConnectionType_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << mainConnectionID; + outputStream << sourceID; + outputStream << sinkID; + outputStream << delay; + outputStream << connectionState; +} + +am_MainConnection_s::am_MainConnection_s(const am_mainConnectionID_t& mainConnectionIDValue, const am_ConnectionState_e& connectionStateValue, const am_sinkID_t& sinkIDValue, const am_sourceID_t& sourceIDValue, const am_timeSync_t& delayValue, const am_ConnectionID_L& listConnectionIDValue): + mainConnectionID(mainConnectionIDValue), + connectionState(connectionStateValue), + sinkID(sinkIDValue), + sourceID(sourceIDValue), + delay(delayValue), + listConnectionID(listConnectionIDValue) +{ +} + + +bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.mainConnectionID == rhs.mainConnectionID && + lhs.connectionState == rhs.connectionState && + lhs.sinkID == rhs.sinkID && + lhs.sourceID == rhs.sourceID && + lhs.delay == rhs.delay && + lhs.listConnectionID == rhs.listConnectionID + ; +} + +void am_MainConnection_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> mainConnectionID; + inputStream >> connectionState; + inputStream >> sinkID; + inputStream >> sourceID; + inputStream >> delay; + inputStream >> listConnectionID; +} + +void am_MainConnection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << mainConnectionID; + outputStream << connectionState; + outputStream << sinkID; + outputStream << sourceID; + outputStream << delay; + outputStream << listConnectionID; +} + +am_NotificationPayload_s::am_NotificationPayload_s(const am_CustomNotificationType_t& typeValue, const int16_t& valueValue): + type(typeValue), + value(valueValue) +{ +} + + +bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.value == rhs.value + ; +} + +void am_NotificationPayload_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> value; +} + +void am_NotificationPayload_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << value; +} + +am_NotificationConfiguration_s::am_NotificationConfiguration_s(const am_CustomNotificationType_t& typeValue, const am_NotificationStatus_e& statusValue, const int16_t& parameterValue): + type(typeValue), + status(statusValue), + parameter(parameterValue) +{ +} + + +bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.status == rhs.status && + lhs.parameter == rhs.parameter + ; +} + +void am_NotificationConfiguration_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> status; + inputStream >> parameter; +} + +void am_NotificationConfiguration_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << status; + outputStream << parameter; +} + +am_Sink_s::am_Sink_s(const am_sinkID_t& sinkIDValue, const std::string& nameValue, const am_domainID_t& domainIDValue, const am_sinkClass_t& sinkClassIDValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_MuteState_e& muteStateValue, const am_mainVolume_t& mainVolumeValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue): + sinkID(sinkIDValue), + name(nameValue), + domainID(domainIDValue), + sinkClassID(sinkClassIDValue), + volume(volumeValue), + visible(visibleValue), + available(availableValue), + muteState(muteStateValue), + mainVolume(mainVolumeValue), + listSoundProperties(listSoundPropertiesValue), + listConnectionFormats(listConnectionFormatsValue), + listMainSoundProperties(listMainSoundPropertiesValue), + listMainNotificationConfigurations(listMainNotificationConfigurationsValue), + listNotificationConfigurations(listNotificationConfigurationsValue) +{ +} + + +bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sinkID == rhs.sinkID && + lhs.name == rhs.name && + lhs.domainID == rhs.domainID && + lhs.sinkClassID == rhs.sinkClassID && + lhs.volume == rhs.volume && + lhs.visible == rhs.visible && + lhs.available == rhs.available && + lhs.muteState == rhs.muteState && + lhs.mainVolume == rhs.mainVolume && + lhs.listSoundProperties == rhs.listSoundProperties && + lhs.listConnectionFormats == rhs.listConnectionFormats && + lhs.listMainSoundProperties == rhs.listMainSoundProperties && + lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations && + lhs.listNotificationConfigurations == rhs.listNotificationConfigurations + ; +} + +void am_Sink_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sinkID; + inputStream >> name; + inputStream >> domainID; + inputStream >> sinkClassID; + inputStream >> volume; + inputStream >> visible; + inputStream >> available; + inputStream >> muteState; + inputStream >> mainVolume; + inputStream >> listSoundProperties; + inputStream >> listConnectionFormats; + inputStream >> listMainSoundProperties; + inputStream >> listMainNotificationConfigurations; + inputStream >> listNotificationConfigurations; +} + +void am_Sink_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sinkID; + outputStream << name; + outputStream << domainID; + outputStream << sinkClassID; + outputStream << volume; + outputStream << visible; + outputStream << available; + outputStream << muteState; + outputStream << mainVolume; + outputStream << listSoundProperties; + outputStream << listConnectionFormats; + outputStream << listMainSoundProperties; + outputStream << listMainNotificationConfigurations; + outputStream << listNotificationConfigurations; +} + +am_Source_s::am_Source_s(const am_sourceID_t& sourceIDValue, const am_domainID_t& domainIDValue, const std::string& nameValue, const am_sourceClass_t& sourceClassIDValue, const am_SourceState_e& sourceStateValue, const am_volume_t& volumeValue, const bool& visibleValue, const am_Availability_s& availableValue, const am_InterruptState_e& interruptStateValue, const am_SoundProperty_L& listSoundPropertiesValue, const am_ConnectionFormat_L& listConnectionFormatsValue, const am_MainSoundProperty_L& listMainSoundPropertiesValue, const am_NotificationConfiguration_L& listMainNotificationConfigurationsValue, const am_NotificationConfiguration_L& listNotificationConfigurationsValue): + sourceID(sourceIDValue), + domainID(domainIDValue), + name(nameValue), + sourceClassID(sourceClassIDValue), + sourceState(sourceStateValue), + volume(volumeValue), + visible(visibleValue), + available(availableValue), + interruptState(interruptStateValue), + listSoundProperties(listSoundPropertiesValue), + listConnectionFormats(listConnectionFormatsValue), + listMainSoundProperties(listMainSoundPropertiesValue), + listMainNotificationConfigurations(listMainNotificationConfigurationsValue), + listNotificationConfigurations(listNotificationConfigurationsValue) +{ +} + + +bool operator==(const am_Source_s& lhs, const am_Source_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.sourceID == rhs.sourceID && + lhs.domainID == rhs.domainID && + lhs.name == rhs.name && + lhs.sourceClassID == rhs.sourceClassID && + lhs.sourceState == rhs.sourceState && + lhs.volume == rhs.volume && + lhs.visible == rhs.visible && + lhs.available == rhs.available && + lhs.interruptState == rhs.interruptState && + lhs.listSoundProperties == rhs.listSoundProperties && + lhs.listConnectionFormats == rhs.listConnectionFormats && + lhs.listMainSoundProperties == rhs.listMainSoundProperties && + lhs.listMainNotificationConfigurations == rhs.listMainNotificationConfigurations && + lhs.listNotificationConfigurations == rhs.listNotificationConfigurations + ; +} + +void am_Source_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> sourceID; + inputStream >> domainID; + inputStream >> name; + inputStream >> sourceClassID; + inputStream >> sourceState; + inputStream >> volume; + inputStream >> visible; + inputStream >> available; + inputStream >> interruptState; + inputStream >> listSoundProperties; + inputStream >> listConnectionFormats; + inputStream >> listMainSoundProperties; + inputStream >> listMainNotificationConfigurations; + inputStream >> listNotificationConfigurations; +} + +void am_Source_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << sourceID; + outputStream << domainID; + outputStream << name; + outputStream << sourceClassID; + outputStream << sourceState; + outputStream << volume; + outputStream << visible; + outputStream << available; + outputStream << interruptState; + outputStream << listSoundProperties; + outputStream << listConnectionFormats; + outputStream << listMainSoundProperties; + outputStream << listMainNotificationConfigurations; + outputStream << listNotificationConfigurations; +} + +am_Domain_s::am_Domain_s(const am_domainID_t& domainIDValue, const std::string& nameValue, const std::string& busnameValue, const std::string& nodenameValue, const bool& earlyValue, const bool& completeValue, const am_DomainState_e& stateValue): + domainID(domainIDValue), + name(nameValue), + busname(busnameValue), + nodename(nodenameValue), + early(earlyValue), + complete(completeValue), + state(stateValue) +{ +} + + +bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.domainID == rhs.domainID && + lhs.name == rhs.name && + lhs.busname == rhs.busname && + lhs.nodename == rhs.nodename && + lhs.early == rhs.early && + lhs.complete == rhs.complete && + lhs.state == rhs.state + ; +} + +void am_Domain_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> domainID; + inputStream >> name; + inputStream >> busname; + inputStream >> nodename; + inputStream >> early; + inputStream >> complete; + inputStream >> state; +} + +void am_Domain_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << domainID; + outputStream << name; + outputStream << busname; + outputStream << nodename; + outputStream << early; + outputStream << complete; + outputStream << state; +} + +am_EarlyData_s::am_EarlyData_s(const am_EarlyDataType_e& typeValue, const am_DataType_u& sinksourceValue, const am_EarlyData_u& dataValue): + type(typeValue), + sinksource(sinksourceValue), + data(dataValue) +{ +} + + +bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.type == rhs.type && + lhs.sinksource == rhs.sinksource && + lhs.data == rhs.data + ; +} + +void am_EarlyData_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> type; + inputStream >> sinksource; + inputStream >> data; +} + +void am_EarlyData_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << type; + outputStream << sinksource; + outputStream << data; +} + +am_Connection_s::am_Connection_s(const am_connectionID_t& connectionIDValue, const am_sourceID_t& sourceIDValue, const am_sinkID_t& sinkIDValue, const am_timeSync_t& delayValue, const am_CustomConnectionFormat_t& connectionFormatValue): + connectionID(connectionIDValue), + sourceID(sourceIDValue), + sinkID(sinkIDValue), + delay(delayValue), + connectionFormat(connectionFormatValue) +{ +} + + +bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.connectionID == rhs.connectionID && + lhs.sourceID == rhs.sourceID && + lhs.sinkID == rhs.sinkID && + lhs.delay == rhs.delay && + lhs.connectionFormat == rhs.connectionFormat + ; +} + +void am_Connection_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> connectionID; + inputStream >> sourceID; + inputStream >> sinkID; + inputStream >> delay; + inputStream >> connectionFormat; +} + +void am_Connection_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << connectionID; + outputStream << sourceID; + outputStream << sinkID; + outputStream << delay; + outputStream << connectionFormat; +} + +am_Volumes_s::am_Volumes_s(const am_VolumeType_e& volumeTypeValue, const am_DataType_u& volumeIDValue, const am_volume_t& volumeValue, const am_CustomRampType_t& rampValue, const am_time_t& timeValue): + volumeType(volumeTypeValue), + volumeID(volumeIDValue), + volume(volumeValue), + ramp(rampValue), + time(timeValue) +{ +} + + +bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs) { + if (&lhs == &rhs) + return true; + + return + lhs.volumeType == rhs.volumeType && + lhs.volumeID == rhs.volumeID && + lhs.volume == rhs.volume && + lhs.ramp == rhs.ramp && + lhs.time == rhs.time + ; +} + +void am_Volumes_s::readFromInputStream(CommonAPI::InputStream& inputStream) { + inputStream >> volumeType; + inputStream >> volumeID; + inputStream >> volume; + inputStream >> ramp; + inputStream >> time; +} + +void am_Volumes_s::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { + outputStream << volumeType; + outputStream << volumeID; + outputStream << volume; + outputStream << ramp; + outputStream << time; +} + + + +} // namespace am +} // namespace genivi +} // namespace org diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h new file mode 100644 index 0000000..e75db5d --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am.h @@ -0,0 +1,2551 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * @author Christian Linke + */ +#ifndef ORG_GENIVI_am_H_ +#define ORG_GENIVI_am_H_ + + + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/InputStream.h> +#include <CommonAPI/OutputStream.h> +#include <CommonAPI/SerializableStruct.h> +#include <CommonAPI/SerializableVariant.h> +#include <CommonAPI/types.h> +#include <cstdint> +#include <memory> +#include <string> +#include <vector> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace org { +namespace genivi { + +namespace am { + /** + * a source ID + */ + /** + * a source ID + */ + typedef uint16_t am_sourceID_t; + /** + * a mainConnection ID + */ + /** + * a mainConnection ID + */ + typedef uint16_t am_mainConnectionID_t; + /** + * offset time that is introduced in milli seconds. + */ + /** + * offset time that is introduced in milli seconds. + */ + typedef int16_t am_timeSync_t; + /** + * a sink ID + */ + /** + * a sink ID + */ + typedef uint16_t am_sinkID_t; + /** + * represents the connection state + */ + enum class am_ConnectionState_e: int32_t { + CS_UNKNOWN = 0, + /** + * This means the connection is just building up + */ + CS_CONNECTING = 1, + /** + * the connection is ready to be used + */ + CS_CONNECTED = 2, + /** + * the connection is in the course to be knocked down + */ + CS_DISCONNECTING = 3, + /** + * only relevant for connectionStatechanged. Is send after the connection was + * removed + */ + CS_DISCONNECTED = 4, + /** + * this means the connection is still build up but unused at the moment + */ + CS_SUSPENDED = 5, + CS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_ConnectionState_eComparator; + /** + * this type holds all information of connections relevant to the HMI + */ + /** + * this type holds all information of connections relevant to the HMI + */ + struct am_MainConnectionType_s: CommonAPI::SerializableStruct { + /** + * the ID of the mainconnection + */ + am_mainConnectionID_t mainConnectionID; + /** + * the sourceID where the connection starts + */ + am_sourceID_t sourceID; + /** + * the sinkID where the connection ends + */ + am_sinkID_t sinkID; + /** + * the delay of the mainconnection + */ + am_timeSync_t delay; + /** + * the current connection state + */ + am_ConnectionState_e connectionState; + + am_MainConnectionType_s() = default; + am_MainConnectionType_s(const am_mainConnectionID_t& mainConnectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_ConnectionState_e& connectionState); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + typeOutputStream.writeInt32Type(); + } + }; + typedef std::vector<am_MainConnectionType_s> am_MainConnection_L; + /** + * product specific identifier of property + */ + /** + * product specific identifier of property + */ + typedef uint16_t am_CustomClassProperty_t; + /** + * describes class properties + */ + /** + * describes class properties + */ + struct am_ClassProperty_s: CommonAPI::SerializableStruct { + /** + * the property as enum + */ + am_CustomClassProperty_t classProperty; + /** + * the value of the property + */ + int16_t value; + + am_ClassProperty_s() = default; + am_ClassProperty_s(const am_CustomClassProperty_t& classProperty, const int16_t& value); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + } + }; + typedef std::vector<am_ClassProperty_s> am_ClassProperty_L; + typedef uint16_t am_sinkClass_t; + /** + * struct describing sinkclasses + */ + /** + * struct describing sinkclasses + */ + struct am_SinkClass_s: CommonAPI::SerializableStruct { + /** + * the ID of the sinkClass + */ + am_sinkClass_t sinkClassID; + /** + * the name of the sinkClass - must be unique in the system + */ + std::string name; + /** + * the list of the class properties. These are pairs of a project specific enum + * describing the type of the value and an integer holding the real value. + */ + am_ClassProperty_L listClassProperties; + + am_SinkClass_s() = default; + am_SinkClass_s(const am_sinkClass_t& sinkClassID, const std::string& name, const am_ClassProperty_L& listClassProperties); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + } + }; + typedef std::vector<am_SinkClass_s> am_SinkClass_L; + /** + * This is the volume presented on the command interface. It is in the duty of the + * Controller to change the volumes given here into meaningful values on the + * routing interface. + The range of this type is customer specific. + */ + /** + * This is the volume presented on the command interface. It is in the duty of the + * Controller to change the volumes given here into meaningful values on the + * routing interface. + The range of this type is customer specific. + */ + typedef int16_t am_mainVolume_t; + /** + * This project specific value gives the information about reason for reason for + * Source/Sink change + */ + /** + * This project specific value gives the information about reason for reason for + * Source/Sink change + */ + typedef uint16_t am_CustomAvailabilityReason_t; + /** + * with the help of this enum, sinks and sources can report their availability + * state + */ + enum class am_Availability_e: int32_t { + /** + * default + */ + A_UNKNOWN = 0, + /** + * The source / sink is available + */ + A_AVAILABLE = 1, + /** + * the source / sink is not available + */ + A_UNAVAILABLE = 2, + A_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_Availability_eComparator; + enum class am_MuteState_e: int32_t { + /** + * default + */ + MS_UNKNOWN = 0, + /** + * the source / sink is muted + */ + MS_MUTED = 1, + /** + * the source / sink is unmuted + */ + MS_UNMUTED = 2, + MS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_MuteState_eComparator; + /** + * this describes the availability of a sink or a source together with the latest + * change + */ + /** + * this describes the availability of a sink or a source together with the latest + * change + */ + struct am_Availability_s: CommonAPI::SerializableStruct { + /** + * the current availability state + */ + am_Availability_e availability; + /** + * the reason for the last change. This can be used to trigger events that deal + * with state changes. + */ + am_CustomAvailabilityReason_t availabilityReason; + + am_Availability_s() = default; + am_Availability_s(const am_Availability_e& availability, const am_CustomAvailabilityReason_t& availabilityReason); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeInt32Type(); + typeOutputStream.writeUInt16Type(); + } + }; + /** + * this type holds all information of sinks relevant to the HMI + */ + /** + * this type holds all information of sinks relevant to the HMI + */ + struct am_SinkType_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the sink, it is unique in the system. There are 2 ways, ID + * can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_sinkID_t sinkID; + /** + * The name of the sink. Must be unique in the whole system. + */ + std::string name; + /** + * This attribute reflects the availability of the sink. There are several reasons + * why a sink could be not available for the moment: for example the shutdown of + * a sink because of overtemperature or over- & undervoltage. The + * availability consists of two pieces of information: + + Availablility: the + * status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN + + * AvailabilityReason: this informs about the last reason for a change in + * availability. The reasons itself are product specific. + */ + am_Availability_s availability; + /** + * This is the representation of the Volume for the commandInterface. It is used + * by the HMI to set the volume of a sink, the AudioManagerController has to + * transform this into real source and sink volumes. + */ + am_mainVolume_t volume; + am_MuteState_e muteState; + /** + * The sinkClassID references to a sinkClass. With the help of classification, + * rules can be setup to define the system behaviour. + */ + am_sinkClass_t sinkClassID; + + am_SinkType_s() = default; + am_SinkType_s(const am_sinkID_t& sinkID, const std::string& name, const am_Availability_s& availability, const am_mainVolume_t& volume, const am_MuteState_e& muteState, const am_sinkClass_t& sinkClassID); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.writeInt16Type(); + typeOutputStream.writeInt32Type(); + typeOutputStream.writeUInt16Type(); + } + }; + typedef std::vector<am_SinkType_s> am_SinkType_L; + typedef uint16_t am_sourceClass_t; + /** + * struct describing source classes + */ + /** + * struct describing source classes + */ + struct am_SourceClass_s: CommonAPI::SerializableStruct { + /** + * the source ID + */ + am_sourceClass_t sourceClassID; + /** + * the name of the sourceClass - must be unique in the system + */ + std::string name; + /** + * the list of the class properties. These are pairs of a project specific enum + * describing the type of the value and an integer holding the real value. + */ + am_ClassProperty_L listClassProperties; + + am_SourceClass_s() = default; + am_SourceClass_s(const am_sourceClass_t& sourceClassID, const std::string& name, const am_ClassProperty_L& listClassProperties); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + } + }; + typedef std::vector<am_SourceClass_s> am_SourceClass_L; + /** + * this type holds all information of sources relevant to the HMI + */ + /** + * this type holds all information of sources relevant to the HMI + */ + struct am_SourceType_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the source, it is unique in the system. There are 2 ways, ID + * can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_sourceID_t sourceID; + /** + * The name of the source. Must be unique in the whole system. + */ + std::string name; + /** + * the availability of the source + */ + am_Availability_s availability; + /** + * the sourceClassID, indicates the class the source is in. This information can + * be used by the Controller to implement different behaviour for different + * classes. + */ + am_sourceClass_t sourceClassID; + + am_SourceType_s() = default; + am_SourceType_s(const am_sourceID_t& sourceID, const std::string& name, const am_Availability_s& availability, const am_sourceClass_t& sourceClassID); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.writeUInt16Type(); + } + }; + typedef std::vector<am_SourceType_s> am_SourceType_L; + /** + * describes the different system properties. Project specific + */ + /** + * describes the different system properties. Project specific + */ + typedef uint16_t am_CustomSystemPropertyType_t; + /** + * struct describing system properties + */ + /** + * struct describing system properties + */ + struct am_SystemProperty_s: CommonAPI::SerializableStruct { + /** + * the type that is set + */ + am_CustomSystemPropertyType_t type; + /** + * the value + */ + int16_t value; + + am_SystemProperty_s() = default; + am_SystemProperty_s(const am_CustomSystemPropertyType_t& type, const int16_t& value); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + } + }; + typedef std::vector<am_SystemProperty_s> am_SystemProperty_L; + /** + * a connection ID + */ + /** + * a connection ID + */ + typedef uint16_t am_connectionID_t; + typedef std::vector<am_connectionID_t> am_ConnectionID_L; + /** + * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and + * maximum can be limited by actual project. + */ + /** + * The unit is 0.1 db steps,The smallest value -3000 (=AM_MUTE). The minimum and + * maximum can be limited by actual project. + */ + typedef int16_t am_volume_t; + /** + * Project specific sound properties. + */ + /** + * Project specific sound properties. + */ + typedef uint16_t am_CustomSoundPropertyType_t; + /** + * This enum characterizes the data of the EarlyData_t + */ + enum class am_EarlyDataType_e: int32_t { + /** + * default + */ + ES_UNKNOWN = 0, + /** + * the source volume + */ + ED_SOURCE_VOLUME = 1, + /** + * the sink volume + */ + ED_SINK_VOLUME = 2, + /** + * a source property + */ + ED_SOURCE_PROPERTY = 3, + /** + * a sink property + */ + ED_SINK_PROPERTY = 4, + ED_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_EarlyDataType_eComparator; + /** + * struct describing the sound property + */ + /** + * struct describing the sound property + */ + struct am_SoundProperty_s: CommonAPI::SerializableStruct { + /** + * the type of the property - a project specific enum + */ + am_CustomSoundPropertyType_t type; + /** + * the actual value of the property + */ + int16_t value; + + am_SoundProperty_s() = default; + am_SoundProperty_s(const am_CustomSoundPropertyType_t& type, const int16_t& value); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + } + }; + /** + * data type depends of am_EarlyDataType_e: + volume_t in case of ED_SOURCE_VOLUME, + * ED_SINK_VOLUME + soundProperty_t in case of ED_SOURCE_PROPERTY, + * ED_SINK_PROPERTY + */ + /** + * data type depends of am_EarlyDataType_e: + volume_t in case of ED_SOURCE_VOLUME, + * ED_SINK_VOLUME + soundProperty_t in case of ED_SOURCE_PROPERTY, + * ED_SINK_PROPERTY + */ + typedef CommonAPI::Variant<am_volume_t, am_SoundProperty_s> am_EarlyData_u; + /** + * data type depends of am_EarlyDataType_e: + sourceID in case of ED_SOURCE_VOLUME, + * ED_SOURCE_PROPERTY + sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY + */ + /** + * data type depends of am_EarlyDataType_e: + sourceID in case of ED_SOURCE_VOLUME, + * ED_SOURCE_PROPERTY + sinkID in case of ED_SINK_VOLUME, ED_SINK_PROPERTY + */ + typedef CommonAPI::Variant<am_sinkID_t, am_sourceID_t> am_DataType_u; + struct am_EarlyData_s: CommonAPI::SerializableStruct { + am_EarlyDataType_e type; + am_DataType_u sinksource; + am_EarlyData_u data; + + am_EarlyData_s() = default; + am_EarlyData_s(const am_EarlyDataType_e& type, const am_DataType_u& sinksource, const am_EarlyData_u& data); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeInt32Type(); + typeOutputStream.writeVariantType(); + typeOutputStream.writeVariantType(); + } + }; + typedef std::vector<am_EarlyData_s> am_EarlyData_L; + /** + * Here are all SoundProperties that can be set via the CommandInterface. Product + * specific + */ + /** + * Here are all SoundProperties that can be set via the CommandInterface. Product + * specific + */ + typedef uint16_t am_CustomMainSoundPropertyType_t; + /** + * struct describung mainsound property + */ + /** + * struct describung mainsound property + */ + struct am_MainSoundProperty_s: CommonAPI::SerializableStruct { + /** + * the type of the property + */ + am_CustomMainSoundPropertyType_t type; + /** + * the actual value + */ + int16_t value; + + am_MainSoundProperty_s() = default; + am_MainSoundProperty_s(const am_CustomMainSoundPropertyType_t& type, const int16_t& value); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + } + }; + typedef std::vector<am_MainSoundProperty_s> am_MainSoundProperty_L; + /** + * gives the type of the Notification. + */ + /** + * gives the type of the Notification. + */ + typedef uint16_t am_CustomNotificationType_t; + enum class am_NotificationStatus_e: int32_t { + NS_UNKNOWN = 0, + /** + * No notification, the function is turned off + */ + NS_OFF = 1, + /** + * Periodic notifications are sent out. The period in ms is given by + * am_NotificationParameter + */ + NS_PERIODIC = 2, + /** + * The notification is sent out when the minimum given by am_NotificationParameter + * is reached. + */ + NS_MINIMUM = 3, + /** + * The notification is sent out when the maximum given by am_NotificationParameter + * is reached. + */ + NS_MAXIMUM = 4, + /** + * The notification is sent out when a change happened. The Resolution of the + * change is defined by am_NotificationParameter. + */ + NS_CHANGE_ = 5, + NS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_NotificationStatus_eComparator; + /** + * This struct holds information about the configuration for notifications + */ + /** + * This struct holds information about the configuration for notifications + */ + struct am_NotificationConfiguration_s: CommonAPI::SerializableStruct { + /** + * The notification type of the notification + */ + am_CustomNotificationType_t type; + /** + * The Notification status. This can be periodic, min/max value based or even off + * for example + */ + am_NotificationStatus_e status; + /** + * This gives additional information to the notification status. + Relation between + * notification status and the value: + NS_PERIODIC - the period in ms + NS_MINIMUM + * - the minimum value that triggers the notification + NS_MAXIMUM - the maximum + * value that triggers the notifcation + NS_CHANGE - the resolution of the change + * value + */ + int16_t parameter; + + am_NotificationConfiguration_s() = default; + am_NotificationConfiguration_s(const am_CustomNotificationType_t& type, const am_NotificationStatus_e& status, const int16_t& parameter); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt32Type(); + typeOutputStream.writeInt16Type(); + } + }; + typedef std::vector<am_NotificationConfiguration_s> am_NotificationConfiguration_L; + /** + * a domain ID + */ + /** + * a domain ID + */ + typedef uint16_t am_domainID_t; + /** + * This project specific value classifies the format in which data is exchanged + * within a connection. + */ + /** + * This project specific value classifies the format in which data is exchanged + * within a connection. + */ + typedef uint16_t am_CustomConnectionFormat_t; + /** + * This represents one "hopp" in a route + */ + /** + * This represents one "hopp" in a route + */ + struct am_RoutingElement_s: CommonAPI::SerializableStruct { + /** + * the source ID + */ + am_sourceID_t sourceID; + /** + * the sinkID + */ + am_sinkID_t sinkID; + /** + * the domainID the routeElement is in + */ + am_domainID_t domainID; + /** + * the connectionformat that is used for the route + */ + am_CustomConnectionFormat_t connectionFormat; + + am_RoutingElement_s() = default; + am_RoutingElement_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_domainID_t& domainID, const am_CustomConnectionFormat_t& connectionFormat); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + } + }; + typedef std::vector<am_RoutingElement_s> am_RoutingElement_L; + typedef std::vector<am_SoundProperty_s> am_SoundProperty_L; + /** + * time in ms! + */ + /** + * time in ms! + */ + typedef int16_t am_time_t; + /** + * For products, different ramp types can be defined here. + It is in the + * responsibility of the product to make sure that the routing plugins are aware + * of the ramp types used. + */ + /** + * For products, different ramp types can be defined here. + It is in the + * responsibility of the product to make sure that the routing plugins are aware + * of the ramp types used. + */ + typedef uint16_t am_CustomRampType_t; + /** + * This datatype determines if a sourceID or a sinkID is used in the union + * following + */ + enum class am_VolumeType_e: int32_t { + VT_UNKNOWN = 0, + /** + * the following type is a sink + */ + VT_SINK = 1, + /** + * the following type is a source + */ + VT_SOURCE = 2, + VT_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_VolumeType_eComparator; + /** + * This types describe a mixed description for source and sinks volumes. + */ + /** + * This types describe a mixed description for source and sinks volumes. + */ + struct am_Volumes_s: CommonAPI::SerializableStruct { + /** + * describes the type of the volume: source or sink. + */ + am_VolumeType_e volumeType; + /** + * either sourceID or sinkID + */ + am_DataType_u volumeID; + /** + * The volume + */ + am_volume_t volume; + /** + * the ramp that shall be driven + */ + am_CustomRampType_t ramp; + /** + * the time for the ramp + */ + am_time_t time; + + am_Volumes_s() = default; + am_Volumes_s(const am_VolumeType_e& volumeType, const am_DataType_u& volumeID, const am_volume_t& volume, const am_CustomRampType_t& ramp, const am_time_t& time); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeInt32Type(); + typeOutputStream.writeVariantType(); + typeOutputStream.writeInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + } + }; + typedef std::vector<am_Volumes_s> am_Volumes_L; + typedef std::vector<am_CustomConnectionFormat_t> am_ConnectionFormat_L; + typedef bool am_bool_t; + typedef std::vector<am_bool_t> am_Convertion_L; + /** + * a gateway ID + */ + /** + * a gateway ID + */ + typedef uint16_t am_gatewayID_t; + /** + * a converter ID + */ + /** + * a converter ID + */ + typedef uint16_t am_converterID_t; + /** + * a crossfader ID + */ + /** + * a crossfader ID + */ + typedef uint16_t am_crossfaderID_t; + /** + * speed + */ + /** + * speed + */ + typedef uint16_t am_speed_t; + /** + * describes the active sink of a crossfader. + */ + enum class am_HotSink_e: int32_t { + /** + * default + */ + HS_UNKNOWN = 0, + /** + * sinkA is active + */ + HS_SINKA = 1, + /** + * sinkB is active + */ + HS_SINKB = 2, + /** + * the crossfader is in the transition state + */ + HS_INTERMEDIATE = 3, + HS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_HotSink_eComparator; + enum class am_DomainState_e: int32_t { + /** + * default + */ + DS_UNKNOWN = 0, + /** + * the domain is controlled by the daemon + */ + DS_CONTROLLED = 1, + /** + * the domain is independent starting up + */ + DS_INDEPENDENT_STARTUP = 1, + /** + * the domain is independent running down + */ + DS_INDEPENDENT_RUNDOWN = 2, + DS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_DomainState_eComparator; + /** + * the errors of the audiomanager. All possible errors are in here. This enum is + * used widely as return parameter. + */ + enum class am_Error_e: int32_t { + /** + * no error - positive reply + */ + E_OK = 0, + /** + * default + */ + E_UNKNOWN = 1, + /** + * value out of range + */ + E_OUT_OF_RANGE = 2, + /** + * not used + */ + E_NOT_USED = 3, + /** + * a database error occurred + */ + E_DATABASE_ERROR = 4, + /** + * the desired object already exists + */ + E_ALREADY_EXISTS = 5, + /** + * there is no change + */ + E_NO_CHANGE = 6, + /** + * the desired action is not possible + */ + E_NOT_POSSIBLE = 7, + /** + * the desired object is non existent + */ + E_NON_EXISTENT = 8, + /** + * the asynchronous action was aborted + */ + E_ABORTED = 9, + /** + * This error is returned in case a connect is issued with a connectionFormat that + * cannot be selected for the connection. This could be either due to the + * capabilities of a source or a sink or gateway compatibilities for example + */ + E_WRONG_FORMAT = 10, + E_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_Error_eComparator; + enum class am_InterruptState_e: int32_t { + /** + * default + */ + IS_UNKNOWN = 0, + /** + * the interrupt state is off - no interrupt + */ + IS_OFF = 1, + /** + * the interrupt state is interrupted - the interrupt is active + */ + IS_INTERRUPTED = 2, + IS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_InterruptState_eComparator; + /** + * This enumeration is used to define the type of the action that is correlated to + * a handle. + */ + enum class am_Handle_e: int32_t { + H_UNKNOWN = 0, + H_CONNECT = 1, + H_DISCONNECT = 2, + H_SETSOURCESTATE = 3, + H_SETSINKVOLUME = 4, + H_SETSOURCEVOLUME = 5, + H_SETSINKSOUNDPROPERTY = 6, + H_SETSOURCESOUNDPROPERTY = 7, + H_SETSINKSOUNDPROPERTIES = 8, + H_SETSOURCESOUNDPROPERTIES = 9, + H_CROSSFADE = 10, + H_SETVOLUMES = 11, + H_SETSINKNOTIFICATION = 12, + H_SETSOURCENOTIFICATION = 13, + H_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_Handle_eComparator; + /** + * The source state reflects the state of the source + */ + enum class am_SourceState_e: int32_t { + SS_UNKNNOWN = 0, + /** + * The source can be activly heared + */ + SS_ON = 1, + /** + * The source cannot be heared + */ + SS_OFF = 2, + /** + * The source is paused. Meaning it cannot be heared but should be prepared to + * play again soon. + */ + SS_PAUSED = 3, + SS_MAX + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_SourceState_eComparator; + /** + * This enum describes the ready state of the routing part + */ + enum class am_RoutingReady_e: int32_t { + RR_UNKNOWN = 0, + RR_READY = 1, + RR_RUNDOWN = 2 + }; + + // Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 + struct am_RoutingReady_eComparator; + /** + * a list of routing elements that lead from source to sink + */ + /** + * a list of routing elements that lead from source to sink + */ + struct am_Route_s: CommonAPI::SerializableStruct { + /** + * the sourceID where the route starts + */ + am_sourceID_t sourceID; + /** + * the sinkID where the route ends + */ + am_sinkID_t sinkID; + /** + * the actual route as list of routing elements + */ + am_RoutingElement_L route; + + am_Route_s() = default; + am_Route_s(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_RoutingElement_L& route); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type();typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + } + }; + /** + * This struct describes the attribiutes of a crossfader. + */ + /** + * This struct describes the attribiutes of a crossfader. + */ + struct am_Crossfader_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the crossfader, it is unique in the system. There are 2 ways, + * ID can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManager daemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_crossfaderID_t crossfaderID; + /** + * The name of the crossfader. Must be unique in the whole system. + */ + std::string name; + /** + * The sinkID of the SinkA. Sinks shall be registered before registering the + * crossfader. + */ + am_sinkID_t sinkID_A; + /** + * The sinkID of the SinkB. Sinks shall be registered before registering the + * crossfader. + */ + am_sinkID_t sinkID_B; + /** + * The sourceID of the crossfader source. The source shall be registered before + * the crossfader. + */ + am_sourceID_t sourceID; + /** + * This enum can have 3 states: + + HS_SINKA sinkA is the current hot one, sinkB + * is not audible + HS_SINKB sinkB is the current hot one, sinkB is not + * audible + HS_INTERMEDIATE the fader is stuck in between a cross-fading + * action. This could be due to an abort or an error. Before using the + * crossfader, it must be set to either HS_SINKA or HS_SINKB. + */ + am_HotSink_e hotSink; + + am_Crossfader_s() = default; + am_Crossfader_s(const am_crossfaderID_t& crossfaderID, const std::string& name, const am_sinkID_t& sinkID_A, const am_sinkID_t& sinkID_B, const am_sourceID_t& sourceID, const am_HotSink_e& hotSink); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt32Type(); + } + }; + /** + * This struct describes the attributes of a gateway. + */ + /** + * This struct describes the attributes of a gateway. + */ + struct am_Gateway_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID + * can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_gatewayID_t gatewayID; + /** + * The name of the gateway. Must be unique in the whole system. + */ + std::string name; + /** + * The sinkID of the gateway sink-end. The sink is a full blown sink with + * connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of + * a gateway as non-visible. Care needs to be taken that the connectionsFormats + * match with the ones in the conversionMatrix. If the sink is located in the + * controllingDomain, the ID needs to be retrieved by registering the sink before + * registering the gateway. In case the sink is in a different domain, the ID + * needs to be retrieved via peeking. + */ + am_sinkID_t sinkID; + /** + * The sourceID of the gateway sink-end. The sink is a full blown source with + * connectionFormats, sinkClassIDs etc... It makes sense to register the sources + * of a gateway as non-visible. Care needs to be taken that the + * connectionsFormats match with the ones in the conversionMatrix. If the source + * is located in the controllingDomain, the ID needs to be retrieved by + * registering the source before registering the gateway. In case the source is + * in a different domain, the ID needs to be retrieved via peeking. + */ + am_sourceID_t sourceID; + /** + * The ID of the sink. If the domain is the same like the controlling domain, the + * ID is known due to registration. If the domain is different, the ID needs to + * be retrieved via peeking. + */ + am_domainID_t domainSinkID; + /** + * The ID of the source. If the domain is the same like the controlling domain, + * the ID is known due to registration. If the domain is different, the ID needs + * to be retrieved via peeking. + */ + am_domainID_t domainSourceID; + /** + * This is the ID of the domain that registers the gateway. + */ + am_domainID_t controlDomainID; + /** + * This is the list of available formats on the source side of the gateway. It is + * not defined during the gateway registration but copied from the source + * registration. + */ + am_ConnectionFormat_L listSourceFormats; + /** + * This is the list of available formats on the sink side of the gateway. It is + * not defined during the gateway registration but copied from the sink + * registration. + */ + am_ConnectionFormat_L listSinkFormats; + /** + * This is matrix holding information about the conversion capability of the + * gateway, it's length is defined by the length(listSinkFormats) x + * length(listSourceFormats). + If a SinkFormat can be converted into a + * SourceFormat, the vector will hold a 1, if no conversion is possible, a + * 0. + The data is stored row orientated, where the rows are related to the + * sinksFormats and the columns to the sourceFormats. The first value will hold + * the conversion information from the first sourceFormat to the first sinkFormat + * for example and the seventh value the information about the 3rd sinkFormat to + * the 1st sourceFormat in case we would have 3 sourceFormats. + */ + am_Convertion_L convertionMatrix; + + am_Gateway_s() = default; + am_Gateway_s(const am_gatewayID_t& gatewayID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainSinkID, const am_domainID_t& domainSourceID, const am_domainID_t& controlDomainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeBoolType(); + typeOutputStream.endWriteVectorType(); + } + }; + /** + * This struct describes the attributes of a gateway. + */ + /** + * This struct describes the attributes of a gateway. + */ + struct am_Converter_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the gateway, it is unique in the system. There are 2 ways, ID + * can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_converterID_t converterID; + /** + * The name of the gateway. Must be unique in the whole system. + */ + std::string name; + /** + * The sinkID of the gateway sink-end. The sink is a full blown sink with + * connectionFormats, sinkClassIDs etc... It makes sense to register the sinks of + * a gateway as non-visible. Care needs to be taken that the connectionsFormats + * match with the ones in the conversionMatrix. If the sink is located in the + * controllingDomain, the ID needs to be retrieved by registering the sink before + * registering the gateway. In case the sink is in a different domain, the ID + * needs to be retrieved via peeking. + */ + am_sinkID_t sinkID; + /** + * The sourceID of the gateway sink-end. The sink is a full blown source with + * connectionFormats, sinkClassIDs etc... It makes sense to register the sources + * of a gateway as non-visible. Care needs to be taken that the + * connectionsFormats match with the ones in the conversionMatrix. If the source + * is located in the controllingDomain, the ID needs to be retrieved by + * registering the source before registering the gateway. In case the source is + * in a different domain, the ID needs to be retrieved via peeking. + */ + am_sourceID_t sourceID; + /** + * The ID of the sink. If the domain is the same like the controlling domain, the + * ID is known due to registration. If the domain is different, the ID needs to + * be retrieved via peeking. + */ + am_domainID_t domainID; + /** + * This is the list of available formats on the source side of the gateway. It is + * not defined during the gateway registration but copied from the source + * registration. + */ + am_ConnectionFormat_L listSourceFormats; + /** + * This is the list of available formats on the sink side of the gateway. It is + * not defined during the gateway registration but copied from the sink + * registration. + */ + am_ConnectionFormat_L listSinkFormats; + /** + * This is matrix holding information about the conversion capability of the + * gateway, it's length is defined by the length(listSinkFormats) x + * length(listSourceFormats). + If a SinkFormat can be converted into a + * SourceFormat, the vector will hold a 1, if no conversion is possible, a + * 0. + The data is stored row orientated, where the rows are related to the + * sinksFormats and the columns to the sourceFormats. The first value will hold + * the conversion information from the first sourceFormat to the first sinkFormat + * for example and the seventh value the information about the 3rd sinkFormat to + * the 1st sourceFormat in case we would have 3 sourceFormats. + */ + am_Convertion_L convertionMatrix; + + am_Converter_s() = default; + am_Converter_s(const am_converterID_t& converterID, const std::string& name, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_domainID_t& domainID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeBoolType(); + typeOutputStream.endWriteVectorType(); + } + }; + /** + * a handle is used for asynchronous operations and is uniquely assigned for each + * of this operations + */ + /** + * a handle is used for asynchronous operations and is uniquely assigned for each + * of this operations + */ + struct am_Handle_s: CommonAPI::SerializableStruct { + /** + * the handletype + */ + am_Handle_e handleType; + /** + * the handle as value + */ + uint16_t handle; + + am_Handle_s() = default; + am_Handle_s(const am_Handle_e& handleType, const uint16_t& handle); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeInt32Type(); + typeOutputStream.writeUInt16Type(); + } + }; + /** + * struct that holds attribiutes of a mainconnection + */ + /** + * struct that holds attribiutes of a mainconnection + */ + struct am_MainConnection_s: CommonAPI::SerializableStruct { + /** + * the assigned ID + */ + am_mainConnectionID_t mainConnectionID; + /** + * the current connection state + */ + am_ConnectionState_e connectionState; + /** + * the sinkID + */ + am_sinkID_t sinkID; + /** + * the sourceID + */ + am_sourceID_t sourceID; + /** + * the delay of the connection + */ + am_timeSync_t delay; + /** + * the list of sub connection IDs the mainconnection consists of + */ + am_ConnectionID_L listConnectionID; + + am_MainConnection_s() = default; + am_MainConnection_s(const am_mainConnectionID_t& mainConnectionID, const am_ConnectionState_e& connectionState, const am_sinkID_t& sinkID, const am_sourceID_t& sourceID, const am_timeSync_t& delay, const am_ConnectionID_L& listConnectionID); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt32Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + } + }; + /** + * This struct holds the payload of a notification. + */ + /** + * This struct holds the payload of a notification. + */ + struct am_NotificationPayload_s: CommonAPI::SerializableStruct { + /** + * This defines the notification type + */ + am_CustomNotificationType_t type; + /** + * This is finally the value of the notification. It's meaning depends on the + * notificationType + */ + int16_t value; + + am_NotificationPayload_s() = default; + am_NotificationPayload_s(const am_CustomNotificationType_t& type, const int16_t& value); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + } + }; + /** + * This struct describes the attribiutes of a sink + */ + /** + * This struct describes the attribiutes of a sink + */ + struct am_Sink_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the sink, it is unique in the system. There are 2 ways, ID + * can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_sinkID_t sinkID; + /** + * The name of the sink. Must be unique in the whole system. + */ + std::string name; + /** + * The domainID is the domain the sink belongs to. A sink can only be in one + * domain. + */ + am_domainID_t domainID; + /** + * The sinkClassID references to a sinkClass. With the help of classification, + * rules can be setup to define the system behaviour. + */ + am_sinkClass_t sinkClassID; + /** + * This is the volume of the sink. It is set by the AudioManagerController. + */ + am_volume_t volume; + /** + * This Boolean flag indicates whether a sink is visible to the commandInterface + * or not. If the User must have the possibility to choose the source in the HMI, + * it must be visible. But there are also good reasons for invisible sinks, for + * example if the sink is part of a crossfader or gateway. HMI relevant changes + * in visible sinks will be automatically reported by the daemon to the + * commandInterface. + */ + bool visible; + /** + * This attribute reflects the availability of the sink. There are several reasons + * why a sink could be not available for the moment: for example the shutdown of + * a sink because of overtemperature or over- & undervoltage. The + * availability consists of two pieces of information: + + Availablility: the + * status itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN + + * AvailabilityReason: this informs about the last reason for a change in + * availability. The reasons itself are product specific. + */ + am_Availability_s available; + /** + * This attribute reflects the muteState of the sink. The information is not the + * "real" state of the sink, but the HMI representation for he commandInterface + * controlled by the AudioManagerController. + */ + am_MuteState_e muteState; + /** + * This is the representation of the Volume for the commandInterface. It is used + * by the HMI to set the volume of a sink, the AudioManagerController has to + * transform this into real source and sink volumes. + */ + am_mainVolume_t mainVolume; + /** + * This is the list of soundProperties, that the sink is capable of. The + * soundProperties itself are project specific. For sinks, a possible + * soundProperty could be for example settings. + */ + am_SoundProperty_L listSoundProperties; + /** + * This list holds information about the formats that the Source is capable of + * supporting when delivering audio. + */ + am_ConnectionFormat_L listConnectionFormats; + /** + * This is the list of the available mainSoundProperties. The principle is the + * same than with soundProperties, but they are only visible to the + * CommandInterface. + */ + am_MainSoundProperty_L listMainSoundProperties; + /** + * This is the list of the MainNotificationConfigurations. These notifications + * work on the level of command interface. + */ + am_NotificationConfiguration_L listMainNotificationConfigurations; + /** + * This is the list of the NotificationConfigurations. These notifications work on + * the level of RoutingPlugins. + */ + am_NotificationConfiguration_L listNotificationConfigurations; + + am_Sink_s() = default; + am_Sink_s(const am_sinkID_t& sinkID, const std::string& name, const am_domainID_t& domainID, const am_sinkClass_t& sinkClassID, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_MuteState_e& muteState, const am_mainVolume_t& mainVolume, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + typeOutputStream.writeBoolType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.writeInt32Type(); + typeOutputStream.writeInt16Type(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + } + }; + /** + * This struct describes the attribiutes of a source + */ + /** + * This struct describes the attribiutes of a source + */ + struct am_Source_s: CommonAPI::SerializableStruct { + /** + * This is the ID of the source, it is unique in the system. There are 2 ways, ID + * can be created: either it is assigned during the registration process (in a + * dynamic context, uniqueness will be ensured by the AudioManagerDaemon), or it + * is a fixed (the project has to ensure the uniqueness of the ID). + */ + am_sourceID_t sourceID; + /** + * The domainID is the domain the source belongs to. A source can only be in one + * domain. + */ + am_domainID_t domainID; + /** + * The name of the source. Must be unique in the whole system. + */ + std::string name; + /** + * the sourceClassID, indicates the class the source is in. This information can + * be used by the Controller to implement different behaviour for different + * classes. + */ + am_sourceClass_t sourceClassID; + /** + * The source state is an indication towards the source if it is actively heard or + * not. The source can use this information to implement features like automatic + * spin down of CD's in case the CD is not the active source or AF following of a + * tuner that is not actively heard. The source state is set by the + * AudioManagerController.There are 3 possible states: + + SS_ON: the source is + * active + SS_OFF: the source is off + SS_PAUSED: the source is paused and + * not active. + */ + am_SourceState_e sourceState; + /** + * This is the volume of the source. It is set by the AudioManagerController. It + * is used to adopt different audiolevels in a system and mixing of sources (e.g. + * navigation hints & music). + */ + am_volume_t volume; + /** + * This Boolean flag indicates whether a source is visible to the commandInterface + * or not. If the User must have the possibility to choose the source in the HMI, + * it must be visible. But there are also good reasons for invisible sources, for + * example if the source is part of a crossfader or gateway. HMI relevant changes + * in visible sources will be automatically reported by the daemon to the + * commandInterface. + */ + bool visible; + /** + * This attribute reflects the availability of the source. There are several + * reasons why a source could be not available for the moment. For example a CD + * player which has no CD entered in the slot can be unavailable, or a USB player + * with no or unreadable stick attached. Other scenarios involve the shutdown of + * a source because of overtemperature or over- & undervoltage. The + * availability consists of two informations: + + Availablility: the status + * itself, can be A_AVAILABLE, A_UNAVAILABLE or A_UNKNOWN + + * AvailabilityReason: this informs about the last reason for a change in + * availability. The reasons itself are product specific. + */ + am_Availability_s available; + /** + * Some special sources can have special behaviors, the are so called "Low Level + * Interrupts". Here the current status is documented. The information can be + * used by the AudioManagerController to react to the changes by for example + * lowering the volume of the mainSources. The two states are + + IS_OFF: the + * interrupt is not active at the moment + IS_INTERRUPTED: the interrupt is + * playing at the moment. + */ + am_InterruptState_e interruptState; + /** + * This is the list of soundProperties, that the source is capable of. The + * soundProperties itself are project specific. For sources, a possible + * soundProperty could be navigation volume offset, for example. + */ + am_SoundProperty_L listSoundProperties; + /** + * This list holds information about the formats that the Source is capable of + * supporting when delivering audio. + */ + am_ConnectionFormat_L listConnectionFormats; + /** + * This is the list of the available mainSoundProperties. The principle is the + * same than with soundProperties, but they are only visible to the + * CommandInterface. + */ + am_MainSoundProperty_L listMainSoundProperties; + /** + * The list of MainNotificationConfigurations. These notifications work on the + * level of CommandInterface. + */ + am_NotificationConfiguration_L listMainNotificationConfigurations; + /** + * The list of MainNotificationConfigurations. These notifications work on the + * level of RoutingInterface. + */ + am_NotificationConfiguration_L listNotificationConfigurations; + + am_Source_s() = default; + am_Source_s(const am_sourceID_t& sourceID, const am_domainID_t& domainID, const std::string& name, const am_sourceClass_t& sourceClassID, const am_SourceState_e& sourceState, const am_volume_t& volume, const bool& visible, const am_Availability_s& available, const am_InterruptState_e& interruptState, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, const am_NotificationConfiguration_L& listMainNotificationConfigurations, const am_NotificationConfiguration_L& listNotificationConfigurations); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt32Type(); + typeOutputStream.writeInt16Type(); + typeOutputStream.writeBoolType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeInt32Type();typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.writeInt32Type(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + typeOutputStream.beginWriteVectorType(); + typeOutputStream.beginWriteStructType(); + typeOutputStream.writeUInt16Type();typeOutputStream.writeInt32Type();typeOutputStream.writeInt16Type(); + typeOutputStream.endWriteStructType(); + typeOutputStream.endWriteVectorType(); + } + }; + /** + * This struct describes the attribiutes of a domain + */ + /** + * This struct describes the attribiutes of a domain + */ + struct am_Domain_s: CommonAPI::SerializableStruct { + /** + * the domain ID + */ + am_domainID_t domainID; + /** + * the name of the domain + */ + std::string name; + /** + * the busname. This is equal to a plugin name and is used to dispatch messages to + * the elements of a plugin + */ + std::string busname; + /** + * the name of the node + */ + std::string nodename; + /** + * indicated if the domain is independent at startup or not + */ + bool early; + /** + * indicates if the domain registration is complete or not + */ + bool complete; + /** + * the current domain state + */ + am_DomainState_e state; + + am_Domain_s() = default; + am_Domain_s(const am_domainID_t& domainID, const std::string& name, const std::string& busname, const std::string& nodename, const bool& early, const bool& complete, const am_DomainState_e& state); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeStringType(); + typeOutputStream.writeStringType(); + typeOutputStream.writeStringType(); + typeOutputStream.writeBoolType(); + typeOutputStream.writeBoolType(); + typeOutputStream.writeInt32Type(); + } + }; + /** + * a connection + */ + /** + * a connection + */ + struct am_Connection_s: CommonAPI::SerializableStruct { + /** + * the assigned ID + */ + am_connectionID_t connectionID; + /** + * the source the audio flows from + */ + am_sourceID_t sourceID; + /** + * the sink the audio flows to + */ + am_sinkID_t sinkID; + /** + * the delay of the conneciton + */ + am_timeSync_t delay; + /** + * the used connectionformat + */ + am_CustomConnectionFormat_t connectionFormat; + + am_Connection_s() = default; + am_Connection_s(const am_connectionID_t& connectionID, const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, const am_timeSync_t& delay, const am_CustomConnectionFormat_t& connectionFormat); + + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeUInt16Type(); + typeOutputStream.writeInt16Type(); + typeOutputStream.writeUInt16Type(); + } + }; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Availability_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Availability_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_Availability_eComparator { + inline bool operator()(const am_Availability_e& lhs, const am_Availability_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_HotSink_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_HotSink_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_HotSink_eComparator { + inline bool operator()(const am_HotSink_e& lhs, const am_HotSink_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_ConnectionState_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_ConnectionState_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_ConnectionState_eComparator { + inline bool operator()(const am_ConnectionState_e& lhs, const am_ConnectionState_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_DomainState_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_DomainState_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_DomainState_eComparator { + inline bool operator()(const am_DomainState_e& lhs, const am_DomainState_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_EarlyDataType_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_EarlyDataType_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_EarlyDataType_eComparator { + inline bool operator()(const am_EarlyDataType_e& lhs, const am_EarlyDataType_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Error_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Error_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_Error_eComparator { + inline bool operator()(const am_Error_e& lhs, const am_Error_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_MuteState_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_MuteState_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_MuteState_eComparator { + inline bool operator()(const am_MuteState_e& lhs, const am_MuteState_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_InterruptState_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_InterruptState_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_InterruptState_eComparator { + inline bool operator()(const am_InterruptState_e& lhs, const am_InterruptState_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_VolumeType_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_VolumeType_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_VolumeType_eComparator { + inline bool operator()(const am_VolumeType_e& lhs, const am_VolumeType_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_NotificationStatus_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_NotificationStatus_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_NotificationStatus_eComparator { + inline bool operator()(const am_NotificationStatus_e& lhs, const am_NotificationStatus_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_Handle_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_Handle_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_Handle_eComparator { + inline bool operator()(const am_Handle_e& lhs, const am_Handle_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_SourceState_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_SourceState_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_SourceState_eComparator { + inline bool operator()(const am_SourceState_e& lhs, const am_SourceState_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, am_RoutingReady_e& enumValue) { + return inputStream.readEnumValue<int32_t>(enumValue); +} + +inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const am_RoutingReady_e& enumValue) { + return outputStream.writeEnumValue(static_cast<int32_t>(enumValue)); +} + +struct am_RoutingReady_eComparator { + inline bool operator()(const am_RoutingReady_e& lhs, const am_RoutingReady_e& rhs) const { + return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs); + } +}; + +bool operator==(const am_Route_s& lhs, const am_Route_s& rhs); +inline bool operator!=(const am_Route_s& lhs, const am_Route_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Availability_s& lhs, const am_Availability_s& rhs); +inline bool operator!=(const am_Availability_s& lhs, const am_Availability_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs); +inline bool operator!=(const am_ClassProperty_s& lhs, const am_ClassProperty_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs); +inline bool operator!=(const am_Crossfader_s& lhs, const am_Crossfader_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Gateway_s& lhs, const am_Gateway_s& rhs); +inline bool operator!=(const am_Gateway_s& lhs, const am_Gateway_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Converter_s& lhs, const am_Converter_s& rhs); +inline bool operator!=(const am_Converter_s& lhs, const am_Converter_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs); +inline bool operator!=(const am_RoutingElement_s& lhs, const am_RoutingElement_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs); +inline bool operator!=(const am_SoundProperty_s& lhs, const am_SoundProperty_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs); +inline bool operator!=(const am_SystemProperty_s& lhs, const am_SystemProperty_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs); +inline bool operator!=(const am_SinkClass_s& lhs, const am_SinkClass_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs); +inline bool operator!=(const am_SourceClass_s& lhs, const am_SourceClass_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_SourceType_s& lhs, const am_SourceType_s& rhs); +inline bool operator!=(const am_SourceType_s& lhs, const am_SourceType_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_SinkType_s& lhs, const am_SinkType_s& rhs); +inline bool operator!=(const am_SinkType_s& lhs, const am_SinkType_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Handle_s& lhs, const am_Handle_s& rhs); +inline bool operator!=(const am_Handle_s& lhs, const am_Handle_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs); +inline bool operator!=(const am_MainSoundProperty_s& lhs, const am_MainSoundProperty_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs); +inline bool operator!=(const am_MainConnectionType_s& lhs, const am_MainConnectionType_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs); +inline bool operator!=(const am_MainConnection_s& lhs, const am_MainConnection_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs); +inline bool operator!=(const am_NotificationPayload_s& lhs, const am_NotificationPayload_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs); +inline bool operator!=(const am_NotificationConfiguration_s& lhs, const am_NotificationConfiguration_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Sink_s& lhs, const am_Sink_s& rhs); +inline bool operator!=(const am_Sink_s& lhs, const am_Sink_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Source_s& lhs, const am_Source_s& rhs); +inline bool operator!=(const am_Source_s& lhs, const am_Source_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Domain_s& lhs, const am_Domain_s& rhs); +inline bool operator!=(const am_Domain_s& lhs, const am_Domain_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs); +inline bool operator!=(const am_EarlyData_s& lhs, const am_EarlyData_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Connection_s& lhs, const am_Connection_s& rhs); +inline bool operator!=(const am_Connection_s& lhs, const am_Connection_s& rhs) { + return !(lhs == rhs); +} +bool operator==(const am_Volumes_s& lhs, const am_Volumes_s& rhs); +inline bool operator!=(const am_Volumes_s& lhs, const am_Volumes_s& rhs) { + return !(lhs == rhs); +} + + +static inline const char* getTypeCollectionName() { + static const char* typeCollectionName = "org.genivi.am"; + return typeCollectionName; +} + +inline CommonAPI::Version getTypeCollectionVersion() { + return CommonAPI::Version(2, 0); +} + +} // namespace am + +} // namespace genivi +} // namespace org + +namespace CommonAPI { + + template<> + struct BasicTypeWriter<org::genivi::am::am_Availability_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_Availability_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Availability_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_Availability_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Availability_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_HotSink_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_HotSink_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_HotSink_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_HotSink_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_HotSink_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_ConnectionState_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_ConnectionState_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_ConnectionState_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_ConnectionState_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_ConnectionState_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_DomainState_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_DomainState_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_DomainState_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_DomainState_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_DomainState_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_EarlyDataType_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_EarlyDataType_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_EarlyDataType_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_EarlyDataType_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_EarlyDataType_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_Error_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_Error_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Error_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_Error_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Error_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_MuteState_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_MuteState_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_MuteState_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_MuteState_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_MuteState_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_InterruptState_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_InterruptState_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_InterruptState_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_InterruptState_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_InterruptState_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_VolumeType_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_VolumeType_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_VolumeType_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_VolumeType_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_VolumeType_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_NotificationStatus_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_NotificationStatus_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_NotificationStatus_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_NotificationStatus_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_NotificationStatus_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_Handle_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_Handle_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_Handle_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_Handle_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_Handle_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_SourceState_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_SourceState_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_SourceState_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_SourceState_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_SourceState_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + template<> + struct BasicTypeWriter<org::genivi::am::am_RoutingReady_e> { + inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { + typeStream.writeInt32EnumType(); + } + }; + + template<> + struct InputStreamVectorHelper<org::genivi::am::am_RoutingReady_e> { + static void beginReadVector(InputStream& inputStream, const std::vector<org::genivi::am::am_RoutingReady_e>& vectorValue) { + inputStream.beginReadInt32EnumVector(); + } + }; + + template <> + struct OutputStreamVectorHelper<org::genivi::am::am_RoutingReady_e> { + static void beginWriteVector(OutputStream& outputStream, const std::vector<org::genivi::am::am_RoutingReady_e>& vectorValue) { + outputStream.beginWriteInt32EnumVector(vectorValue.size()); + } + }; + +} + + +namespace std { + //Hash for am_Availability_e + template<> + struct hash<org::genivi::am::am_Availability_e> { + inline size_t operator()(const org::genivi::am::am_Availability_e& am_Availability_e) const { + return static_cast<int32_t>(am_Availability_e); + } + }; + //Hash for am_HotSink_e + template<> + struct hash<org::genivi::am::am_HotSink_e> { + inline size_t operator()(const org::genivi::am::am_HotSink_e& am_HotSink_e) const { + return static_cast<int32_t>(am_HotSink_e); + } + }; + //Hash for am_ConnectionState_e + template<> + struct hash<org::genivi::am::am_ConnectionState_e> { + inline size_t operator()(const org::genivi::am::am_ConnectionState_e& am_ConnectionState_e) const { + return static_cast<int32_t>(am_ConnectionState_e); + } + }; + //Hash for am_DomainState_e + template<> + struct hash<org::genivi::am::am_DomainState_e> { + inline size_t operator()(const org::genivi::am::am_DomainState_e& am_DomainState_e) const { + return static_cast<int32_t>(am_DomainState_e); + } + }; + //Hash for am_EarlyDataType_e + template<> + struct hash<org::genivi::am::am_EarlyDataType_e> { + inline size_t operator()(const org::genivi::am::am_EarlyDataType_e& am_EarlyDataType_e) const { + return static_cast<int32_t>(am_EarlyDataType_e); + } + }; + //Hash for am_Error_e + template<> + struct hash<org::genivi::am::am_Error_e> { + inline size_t operator()(const org::genivi::am::am_Error_e& am_Error_e) const { + return static_cast<int32_t>(am_Error_e); + } + }; + //Hash for am_MuteState_e + template<> + struct hash<org::genivi::am::am_MuteState_e> { + inline size_t operator()(const org::genivi::am::am_MuteState_e& am_MuteState_e) const { + return static_cast<int32_t>(am_MuteState_e); + } + }; + //Hash for am_InterruptState_e + template<> + struct hash<org::genivi::am::am_InterruptState_e> { + inline size_t operator()(const org::genivi::am::am_InterruptState_e& am_InterruptState_e) const { + return static_cast<int32_t>(am_InterruptState_e); + } + }; + //Hash for am_VolumeType_e + template<> + struct hash<org::genivi::am::am_VolumeType_e> { + inline size_t operator()(const org::genivi::am::am_VolumeType_e& am_VolumeType_e) const { + return static_cast<int32_t>(am_VolumeType_e); + } + }; + //Hash for am_NotificationStatus_e + template<> + struct hash<org::genivi::am::am_NotificationStatus_e> { + inline size_t operator()(const org::genivi::am::am_NotificationStatus_e& am_NotificationStatus_e) const { + return static_cast<int32_t>(am_NotificationStatus_e); + } + }; + //Hash for am_Handle_e + template<> + struct hash<org::genivi::am::am_Handle_e> { + inline size_t operator()(const org::genivi::am::am_Handle_e& am_Handle_e) const { + return static_cast<int32_t>(am_Handle_e); + } + }; + //Hash for am_SourceState_e + template<> + struct hash<org::genivi::am::am_SourceState_e> { + inline size_t operator()(const org::genivi::am::am_SourceState_e& am_SourceState_e) const { + return static_cast<int32_t>(am_SourceState_e); + } + }; + //Hash for am_RoutingReady_e + template<> + struct hash<org::genivi::am::am_RoutingReady_e> { + inline size_t operator()(const org::genivi::am::am_RoutingReady_e& am_RoutingReady_e) const { + return static_cast<int32_t>(am_RoutingReady_e); + } + }; +} + +#endif // ORG_GENIVI_am_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h new file mode 100644 index 0000000..106e5ad --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControl.h @@ -0,0 +1,67 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_H_ +#define ORG_GENIVI_AM_Command_Control_H_ + + + + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/types.h> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace org { +namespace genivi { +namespace am { + +class CommandControl { + public: + virtual ~CommandControl() { } + + static inline const char* getInterfaceId(); + static inline CommonAPI::Version getInterfaceVersion(); +}; + +const char* CommandControl::getInterfaceId() { + static const char* interfaceId = "org.genivi.am.CommandControl"; + return interfaceId; +} + +CommonAPI::Version CommandControl::getInterfaceVersion() { + return CommonAPI::Version(2, 0); +} + + +} // namespace am +} // namespace genivi +} // namespace org + +namespace CommonAPI { + +} + + +namespace std { + //hashes for types + + //hashes for error types +} + +#endif // ORG_GENIVI_AM_Command_Control_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp new file mode 100644 index 0000000..bf46af3 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.cpp @@ -0,0 +1,651 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#include "CommandControlDBusProxy.h" + +namespace org { +namespace genivi { +namespace am { + +std::shared_ptr<CommonAPI::DBus::DBusProxy> createCommandControlDBusProxy( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& interfaceName, + const std::string& busName, + const std::string& objectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection) { + return std::make_shared<CommandControlDBusProxy>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection); +} + +INITIALIZER(registerCommandControlDBusProxy) { + CommonAPI::DBus::DBusFactory::registerProxyFactoryMethod(CommandControl::getInterfaceId(), + &createCommandControlDBusProxy); +} + +CommandControlDBusProxy::CommandControlDBusProxy( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& interfaceName, + const std::string& busName, + const std::string& objectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection): + CommonAPI::DBus::DBusProxy(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection) +, newMainConnection_(*this, "newMainConnection", "(qqqni)"), + removedMainConnection_(*this, "removedMainConnection", "q"), + newSink_(*this, "newSink", "(qs(iq)niq)"), + removedSink_(*this, "removedSink", "q"), + newSource_(*this, "newSource", "(qs(iq)q)"), + removedSource_(*this, "removedSource", "q"), + numberOfSinkClassesChanged_(*this, "numberOfSinkClassesChanged", ""), + numberOfSourceClassesChanged_(*this, "numberOfSourceClassesChanged", ""), + mainConnectionStateChanged_(*this, "mainConnectionStateChanged", "qi"), + mainSinkSoundPropertyChanged_(*this, "mainSinkSoundPropertyChanged", "q(qn)"), + mainSourceSoundPropertyChanged_(*this, "mainSourceSoundPropertyChanged", "q(qn)"), + sinkAvailabilityChanged_(*this, "sinkAvailabilityChanged", "q(iq)"), + sourceAvailabilityChanged_(*this, "sourceAvailabilityChanged", "q(iq)"), + volumeChanged_(*this, "volumeChanged", "qn"), + sinkMuteStateChanged_(*this, "sinkMuteStateChanged", "qi"), + systemPropertyChanged_(*this, "systemPropertyChanged", "(qn)"), + timingInformationChanged_(*this, "timingInformationChanged", "qn"), + sinkUpdated_(*this, "sinkUpdated", "qqa(qn)"), + sourceUpdated_(*this, "sourceUpdated", "qqa(qn)"), + sinkNotification_(*this, "sinkNotification", "q(qn)"), + sourceNotification_(*this, "sourceNotification", "q(qn)"), + mainSinkNotificationConfigurationChanged_(*this, "mainSinkNotificationConfigurationChanged", "q(qin)"), + mainSourceNotificationConfigurationChanged_(*this, "mainSourceNotificationConfigurationChanged", "q(qin)") + { + } + + +CommandControlDBusProxy::NewMainConnectionEvent& CommandControlDBusProxy::getNewMainConnectionEvent() { + return newMainConnection_; +} +CommandControlDBusProxy::RemovedMainConnectionEvent& CommandControlDBusProxy::getRemovedMainConnectionEvent() { + return removedMainConnection_; +} +CommandControlDBusProxy::NewSinkEvent& CommandControlDBusProxy::getNewSinkEvent() { + return newSink_; +} +CommandControlDBusProxy::RemovedSinkEvent& CommandControlDBusProxy::getRemovedSinkEvent() { + return removedSink_; +} +CommandControlDBusProxy::NewSourceEvent& CommandControlDBusProxy::getNewSourceEvent() { + return newSource_; +} +CommandControlDBusProxy::RemovedSourceEvent& CommandControlDBusProxy::getRemovedSourceEvent() { + return removedSource_; +} +CommandControlDBusProxy::NumberOfSinkClassesChangedEvent& CommandControlDBusProxy::getNumberOfSinkClassesChangedEvent() { + return numberOfSinkClassesChanged_; +} +CommandControlDBusProxy::NumberOfSourceClassesChangedEvent& CommandControlDBusProxy::getNumberOfSourceClassesChangedEvent() { + return numberOfSourceClassesChanged_; +} +CommandControlDBusProxy::MainConnectionStateChangedEvent& CommandControlDBusProxy::getMainConnectionStateChangedEvent() { + return mainConnectionStateChanged_; +} +CommandControlDBusProxy::MainSinkSoundPropertyChangedEvent& CommandControlDBusProxy::getMainSinkSoundPropertyChangedEvent() { + return mainSinkSoundPropertyChanged_; +} +CommandControlDBusProxy::MainSourceSoundPropertyChangedEvent& CommandControlDBusProxy::getMainSourceSoundPropertyChangedEvent() { + return mainSourceSoundPropertyChanged_; +} +CommandControlDBusProxy::SinkAvailabilityChangedEvent& CommandControlDBusProxy::getSinkAvailabilityChangedEvent() { + return sinkAvailabilityChanged_; +} +CommandControlDBusProxy::SourceAvailabilityChangedEvent& CommandControlDBusProxy::getSourceAvailabilityChangedEvent() { + return sourceAvailabilityChanged_; +} +CommandControlDBusProxy::VolumeChangedEvent& CommandControlDBusProxy::getVolumeChangedEvent() { + return volumeChanged_; +} +CommandControlDBusProxy::SinkMuteStateChangedEvent& CommandControlDBusProxy::getSinkMuteStateChangedEvent() { + return sinkMuteStateChanged_; +} +CommandControlDBusProxy::SystemPropertyChangedEvent& CommandControlDBusProxy::getSystemPropertyChangedEvent() { + return systemPropertyChanged_; +} +CommandControlDBusProxy::TimingInformationChangedEvent& CommandControlDBusProxy::getTimingInformationChangedEvent() { + return timingInformationChanged_; +} +CommandControlDBusProxy::SinkUpdatedEvent& CommandControlDBusProxy::getSinkUpdatedEvent() { + return sinkUpdated_; +} +CommandControlDBusProxy::SourceUpdatedEvent& CommandControlDBusProxy::getSourceUpdatedEvent() { + return sourceUpdated_; +} +CommandControlDBusProxy::SinkNotificationEvent& CommandControlDBusProxy::getSinkNotificationEvent() { + return sinkNotification_; +} +CommandControlDBusProxy::SourceNotificationEvent& CommandControlDBusProxy::getSourceNotificationEvent() { + return sourceNotification_; +} +CommandControlDBusProxy::MainSinkNotificationConfigurationChangedEvent& CommandControlDBusProxy::getMainSinkNotificationConfigurationChangedEvent() { + return mainSinkNotificationConfigurationChanged_; +} +CommandControlDBusProxy::MainSourceNotificationConfigurationChangedEvent& CommandControlDBusProxy::getMainSourceNotificationConfigurationChangedEvent() { + return mainSourceNotificationConfigurationChanged_; +} + +/** + * connects a source to sink +(at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ +void CommandControlDBusProxy::connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sinkID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_Error_e> >::callMethodWithReply( + *this, + "connect", + "qq", + sourceID, sinkID, + callStatus + , mainConnectionID, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sinkID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_Error_e> >::callMethodAsync( + *this, + "connect", + "qq", + sourceID, sinkID, + std::move(callback)); +} +/** + * disconnects a mainConnection +(at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ +void CommandControlDBusProxy::disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "disconnect", + "q", + mainConnectionID, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "disconnect", + "q", + mainConnectionID, + std::move(callback)); +} +/** + * sets the volume for a sink +(at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ +void CommandControlDBusProxy::setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setVolume", + "qn", + sinkID, volume, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setVolume", + "qn", + sinkID, volume, + std::move(callback)); +} +/** + * This function is used to increment or decrement the current volume for a + * sink. +(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ +void CommandControlDBusProxy::volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, int16_t>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "volumeStep", + "qn", + sinkID, volStep, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, int16_t>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "volumeStep", + "qn", + sinkID, volStep, + std::move(callback)); +} +/** + * sets the mute state of a sink +(at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ +void CommandControlDBusProxy::setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setSinkMuteState", + "qi", + sinkID, muteState, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setSinkMuteState", + "qi", + sinkID, muteState, + std::move(callback)); +} +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +void CommandControlDBusProxy::setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setMainSinkSoundProperty", + "q(qn)", + sinkID, soundProperty, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setMainSinkSoundProperty", + "q(qn)", + sinkID, soundProperty, + std::move(callback)); +} +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +void CommandControlDBusProxy::setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setMainSourceSoundProperty", + "q(qn)", + sourceID, soundProperty, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setMainSourceSoundProperty", + "q(qn)", + sourceID, soundProperty, + std::move(callback)); +} +/** + * is used to set a specific system property. +(at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ +void CommandControlDBusProxy::setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setSystemProperty", + "(qn)", + property, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setSystemProperty", + "(qn)", + property, + std::move(callback)); +} +/** + * returns the actual list of MainConnections +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_MainConnection_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainConnections", + "", + callStatus + , listConnections, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_MainConnection_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainConnections", + "", + std::move(callback)); +} +/** + * returns the actual list of Sinks +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +void CommandControlDBusProxy::getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SinkType_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainSinks", + "", + callStatus + , listMainSinks, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinksAsync(GetListMainSinksAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SinkType_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainSinks", + "", + std::move(callback)); +} +/** + * returns the actual list of Sources +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +void CommandControlDBusProxy::getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SourceType_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainSources", + "", + callStatus + , listMainSources, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SourceType_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainSources", + "", + std::move(callback)); +} +/** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair +(at)return E_OK on + * success, E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainSinkSoundProperties", + "q", + sinkID, + callStatus + , listSoundProperties, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainSinkSoundProperties", + "q", + sinkID, + std::move(callback)); +} +/** + * This is used to retrieve all source sound properties related to a + * source. +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainSourceSoundProperties", + "q", + sourceID, + callStatus + , listSourceProperties, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_MainSoundProperty_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainSourceSoundProperties", + "q", + sourceID, + std::move(callback)); +} +/** + * This is used to retrieve SourceClass Information of all source classes + * +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SourceClass_L, am_Error_e> >::callMethodWithReply( + *this, + "getListSourceClasses", + "", + callStatus + , listSourceClasses, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SourceClass_L, am_Error_e> >::callMethodAsync( + *this, + "getListSourceClasses", + "", + std::move(callback)); +} +/** + * This is used to retrieve SinkClass Information of all sink classes +(at)return + * E_OK on success, E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SinkClass_L, am_Error_e> >::callMethodWithReply( + *this, + "getListSinkClasses", + "", + callStatus + , listSinkClasses, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SinkClass_L, am_Error_e> >::callMethodAsync( + *this, + "getListSinkClasses", + "", + std::move(callback)); +} +/** + * Retrieves a complete list of all systemProperties. +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_L, am_Error_e> >::callMethodWithReply( + *this, + "getListSystemProperties", + "", + callStatus + , listSystemProperties, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<>, + CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_L, am_Error_e> >::callMethodAsync( + *this, + "getListSystemProperties", + "", + std::move(callback)); +} +/** + * returns the delay in ms that the audiopath for the given mainConnection + * has +(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ +void CommandControlDBusProxy::getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_timeSync_t, am_Error_e> >::callMethodWithReply( + *this, + "getTimingInformation", + "q", + mainConnectionID, + callStatus + , delay, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_timeSync_t, am_Error_e> >::callMethodAsync( + *this, + "getTimingInformation", + "q", + mainConnectionID, + std::move(callback)); +} +/** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ +void CommandControlDBusProxy::getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainSinkNotificationConfigurations", + "q", + sinkID, + callStatus + , listMainNotificationConfigurations, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainSinkNotificationConfigurations", + "q", + sinkID, + std::move(callback)); +} +/** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ +void CommandControlDBusProxy::getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodWithReply( + *this, + "getListMainSourceNotificationConfigurations", + "q", + sourceID, + callStatus + , listMainNotificationConfigurations, error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>, + CommonAPI::DBus::DBusSerializableArguments<am_NotificationConfiguration_L, am_Error_e> >::callMethodAsync( + *this, + "getListMainSourceNotificationConfigurations", + "q", + sourceID, + std::move(callback)); +} +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setMainSinkNotificationConfiguration", + "q(qin)", + sinkID, mainNotificationConfiguration, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setMainSinkNotificationConfiguration", + "q(qin)", + sinkID, mainNotificationConfiguration, + std::move(callback)); +} +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ +void CommandControlDBusProxy::setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodWithReply( + *this, + "setMainSourceNotificationConfiguration", + "q(qin)", + sourceID, mainNotificationConfiguration, + callStatus + , error); +} +std::future<CommonAPI::CallStatus> CommandControlDBusProxy::setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>, + CommonAPI::DBus::DBusSerializableArguments<am_Error_e> >::callMethodAsync( + *this, + "setMainSourceNotificationConfiguration", + "q(qin)", + sourceID, mainNotificationConfiguration, + std::move(callback)); +} + + + +void CommandControlDBusProxy::getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const { + ownVersionMajor = 2; + ownVersionMinor = 0; +} + +} // namespace am +} // namespace genivi +} // namespace org diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h new file mode 100644 index 0000000..c2a53ca --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusProxy.h @@ -0,0 +1,266 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_DBUS_PROXY_H_ +#define ORG_GENIVI_AM_Command_Control_DBUS_PROXY_H_ + +#include <org/genivi/am/CommandControlProxyBase.h> + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/DBus/DBusFactory.h> +#include <CommonAPI/DBus/DBusProxy.h> +#include <CommonAPI/DBus/DBusEvent.h> + +#undef COMMONAPI_INTERNAL_COMPILATION + +#include <string> + +namespace org { +namespace genivi { +namespace am { + +class CommandControlDBusProxy: virtual public CommandControlProxyBase, virtual public CommonAPI::DBus::DBusProxy { + public: + CommandControlDBusProxy( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& interfaceName, + const std::string& busName, + const std::string& objectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyconnection); + + virtual ~CommandControlDBusProxy() { } + + + virtual NewMainConnectionEvent& getNewMainConnectionEvent(); + virtual RemovedMainConnectionEvent& getRemovedMainConnectionEvent(); + virtual NewSinkEvent& getNewSinkEvent(); + virtual RemovedSinkEvent& getRemovedSinkEvent(); + virtual NewSourceEvent& getNewSourceEvent(); + virtual RemovedSourceEvent& getRemovedSourceEvent(); + virtual NumberOfSinkClassesChangedEvent& getNumberOfSinkClassesChangedEvent(); + virtual NumberOfSourceClassesChangedEvent& getNumberOfSourceClassesChangedEvent(); + virtual MainConnectionStateChangedEvent& getMainConnectionStateChangedEvent(); + virtual MainSinkSoundPropertyChangedEvent& getMainSinkSoundPropertyChangedEvent(); + virtual MainSourceSoundPropertyChangedEvent& getMainSourceSoundPropertyChangedEvent(); + virtual SinkAvailabilityChangedEvent& getSinkAvailabilityChangedEvent(); + virtual SourceAvailabilityChangedEvent& getSourceAvailabilityChangedEvent(); + virtual VolumeChangedEvent& getVolumeChangedEvent(); + virtual SinkMuteStateChangedEvent& getSinkMuteStateChangedEvent(); + virtual SystemPropertyChangedEvent& getSystemPropertyChangedEvent(); + virtual TimingInformationChangedEvent& getTimingInformationChangedEvent(); + virtual SinkUpdatedEvent& getSinkUpdatedEvent(); + virtual SourceUpdatedEvent& getSourceUpdatedEvent(); + virtual SinkNotificationEvent& getSinkNotificationEvent(); + virtual SourceNotificationEvent& getSourceNotificationEvent(); + virtual MainSinkNotificationConfigurationChangedEvent& getMainSinkNotificationConfigurationChangedEvent(); + virtual MainSourceNotificationConfigurationChangedEvent& getMainSourceNotificationConfigurationChangedEvent(); + + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ + virtual void connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback); + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ + virtual void disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback); + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ + virtual void setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback); + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ + virtual void volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback); + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ + virtual void setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback); + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + virtual void setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback); + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + virtual void setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback); + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ + virtual void setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback); + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + virtual void getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback); + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + virtual void getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainSinksAsync(GetListMainSinksAsyncCallback callback); + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + virtual void getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback); + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + */ + virtual void getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback); + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback); + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback); + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback); + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + virtual void getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback); + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ + virtual void getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback); + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ + virtual void getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback); + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ + virtual void getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback); + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ + virtual void setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback); + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ + virtual void setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error); + virtual std::future<CommonAPI::CallStatus> setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback); + + + virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const; + + private: + + CommonAPI::DBus::DBusEvent<NewMainConnectionEvent> newMainConnection_; + CommonAPI::DBus::DBusEvent<RemovedMainConnectionEvent> removedMainConnection_; + CommonAPI::DBus::DBusEvent<NewSinkEvent> newSink_; + CommonAPI::DBus::DBusEvent<RemovedSinkEvent> removedSink_; + CommonAPI::DBus::DBusEvent<NewSourceEvent> newSource_; + CommonAPI::DBus::DBusEvent<RemovedSourceEvent> removedSource_; + CommonAPI::DBus::DBusEvent<NumberOfSinkClassesChangedEvent> numberOfSinkClassesChanged_; + CommonAPI::DBus::DBusEvent<NumberOfSourceClassesChangedEvent> numberOfSourceClassesChanged_; + CommonAPI::DBus::DBusEvent<MainConnectionStateChangedEvent> mainConnectionStateChanged_; + CommonAPI::DBus::DBusEvent<MainSinkSoundPropertyChangedEvent> mainSinkSoundPropertyChanged_; + CommonAPI::DBus::DBusEvent<MainSourceSoundPropertyChangedEvent> mainSourceSoundPropertyChanged_; + CommonAPI::DBus::DBusEvent<SinkAvailabilityChangedEvent> sinkAvailabilityChanged_; + CommonAPI::DBus::DBusEvent<SourceAvailabilityChangedEvent> sourceAvailabilityChanged_; + CommonAPI::DBus::DBusEvent<VolumeChangedEvent> volumeChanged_; + CommonAPI::DBus::DBusEvent<SinkMuteStateChangedEvent> sinkMuteStateChanged_; + CommonAPI::DBus::DBusEvent<SystemPropertyChangedEvent> systemPropertyChanged_; + CommonAPI::DBus::DBusEvent<TimingInformationChangedEvent> timingInformationChanged_; + CommonAPI::DBus::DBusEvent<SinkUpdatedEvent> sinkUpdated_; + CommonAPI::DBus::DBusEvent<SourceUpdatedEvent> sourceUpdated_; + CommonAPI::DBus::DBusEvent<SinkNotificationEvent> sinkNotification_; + CommonAPI::DBus::DBusEvent<SourceNotificationEvent> sourceNotification_; + CommonAPI::DBus::DBusEvent<MainSinkNotificationConfigurationChangedEvent> mainSinkNotificationConfigurationChanged_; + CommonAPI::DBus::DBusEvent<MainSourceNotificationConfigurationChangedEvent> mainSourceNotificationConfigurationChanged_; + +}; + + + +} // namespace am +} // namespace genivi +} // namespace org + +#endif // ORG_GENIVI_AM_Command_Control_DBUS_PROXY_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp new file mode 100644 index 0000000..6da5cfd --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.cpp @@ -0,0 +1,1096 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +#include "CommandControlDBusStubAdapter.h" +#include <org/genivi/am/CommandControl.h> + +namespace org { +namespace genivi { +namespace am { + +std::shared_ptr<CommonAPI::DBus::DBusStubAdapter> createCommandControlDBusStubAdapter( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& interfaceName, + const std::string& busName, + const std::string& objectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusProxyConnection, + const std::shared_ptr<CommonAPI::StubBase>& stubBase) { + return std::make_shared<CommandControlDBusStubAdapter>(factory, commonApiAddress, interfaceName, busName, objectPath, dbusProxyConnection, stubBase); +} + +INITIALIZER(registerCommandControlDBusStubAdapter) { + CommonAPI::DBus::DBusFactory::registerAdapterFactoryMethod(CommandControl::getInterfaceId(), + &createCommandControlDBusStubAdapter); +} + + + +CommandControlDBusStubAdapterInternal::~CommandControlDBusStubAdapterInternal() { + deactivateManagedInstances(); + CommandControlDBusStubAdapterHelper::deinit(); +} + +void CommandControlDBusStubAdapterInternal::deactivateManagedInstances() { + +} + +const char* CommandControlDBusStubAdapterInternal::getMethodsDBusIntrospectionXmlData() const { + static const std::string introspectionData = + "<method name=\"getInterfaceVersion\">\n" + "<arg name=\"value\" type=\"uu\" direction=\"out\" />" + "</method>\n" + /** + * Callback that is called when the number of connections change + */ + "<signal name=\"newMainConnection\">\n" + "<arg name=\"mainConnection\" type=\"(qqqni)\" />\n" + "</signal>\n" + /** + * Callback that is called when the number of connections change + */ + "<signal name=\"removedMainConnection\">\n" + "<arg name=\"mainConnection\" type=\"q\" />\n" + "</signal>\n" + /** + * Callback that is called when the number of sinks change + */ + "<signal name=\"newSink\">\n" + "<arg name=\"sink\" type=\"(qs(iq)niq)\" />\n" + "</signal>\n" + /** + * Callback that is called when the number of sinks change + */ + "<signal name=\"removedSink\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "</signal>\n" + /** + * Callback that is called when the number of sources change + */ + "<signal name=\"newSource\">\n" + "<arg name=\"source\" type=\"(qs(iq)q)\" />\n" + "</signal>\n" + /** + * Callback that is called when the number of sources change + */ + "<signal name=\"removedSource\">\n" + "<arg name=\"source\" type=\"q\" />\n" + "</signal>\n" + /** + * this callback is fired if the number of sink classes changed + */ + "<signal name=\"numberOfSinkClassesChanged\">\n" + "</signal>\n" + /** + * this callback is fired if the number of source classes changed + */ + "<signal name=\"numberOfSourceClassesChanged\">\n" + "</signal>\n" + /** + * This callback is called when the ConnectionState of a connection changed. + */ + "<signal name=\"mainConnectionStateChanged\">\n" + "<arg name=\"connectionID\" type=\"q\" />\n" + "<arg name=\"connectionState\" type=\"i\" />\n" + "</signal>\n" + /** + * this callback indicates that a sinkSoundProperty has changed. + */ + "<signal name=\"mainSinkSoundPropertyChanged\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"soundProperty\" type=\"(qn)\" />\n" + "</signal>\n" + /** + * this callback indicates that a sourceSoundProperty has changed. + */ + "<signal name=\"mainSourceSoundPropertyChanged\">\n" + "<arg name=\"sourceID\" type=\"q\" />\n" + "<arg name=\"soundProperty\" type=\"(qn)\" />\n" + "</signal>\n" + /** + * this callback is called when the availability of a sink has changed + */ + "<signal name=\"sinkAvailabilityChanged\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"availability\" type=\"(iq)\" />\n" + "</signal>\n" + /** + * this callback is called when the availability of source has changed. + */ + "<signal name=\"sourceAvailabilityChanged\">\n" + "<arg name=\"sourceID\" type=\"q\" />\n" + "<arg name=\"availability\" type=\"(iq)\" />\n" + "</signal>\n" + /** + * this callback indicates a volume change on the indicated sink + */ + "<signal name=\"volumeChanged\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"volume\" type=\"n\" />\n" + "</signal>\n" + /** + * this callback indicates a mute state change on a sink. + */ + "<signal name=\"sinkMuteStateChanged\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"muteState\" type=\"i\" />\n" + "</signal>\n" + /** + * is fired if a systemProperty changed + */ + "<signal name=\"systemPropertyChanged\">\n" + "<arg name=\"systemProperty\" type=\"(qn)\" />\n" + "</signal>\n" + /** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ + "<signal name=\"timingInformationChanged\">\n" + "<arg name=\"mainConnectionID\" type=\"q\" />\n" + "<arg name=\"time\" type=\"n\" />\n" + "</signal>\n" + /** + * This callback is called when a sink is updated. + */ + "<signal name=\"sinkUpdated\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"sinkClassID\" type=\"q\" />\n" + "<arg name=\"listMainSoundProperties\" type=\"a(qn)\" />\n" + "</signal>\n" + /** + * This callback is called when a source is updated. + */ + "<signal name=\"sourceUpdated\">\n" + "<arg name=\"sourceID\" type=\"q\" />\n" + "<arg name=\"sourceClassID\" type=\"q\" />\n" + "<arg name=\"listMainSoundProperties\" type=\"a(qn)\" />\n" + "</signal>\n" + /** + * This callback is called when a notificated value of a sink changes. + */ + "<signal name=\"sinkNotification\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"notification\" type=\"(qn)\" />\n" + "</signal>\n" + /** + * This callback is called when a notifcated value of a source changes. + */ + "<signal name=\"sourceNotification\">\n" + "<arg name=\"sourceID\" type=\"q\" />\n" + "<arg name=\"notification\" type=\"(qn)\" />\n" + "</signal>\n" + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + "<signal name=\"mainSinkNotificationConfigurationChanged\">\n" + "<arg name=\"sinkID\" type=\"q\" />\n" + "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" />\n" + "</signal>\n" + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + "<signal name=\"mainSourceNotificationConfigurationChanged\">\n" + "<arg name=\"sourceID\" type=\"q\" />\n" + "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" />\n" + "</signal>\n" + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ + "<method name=\"connect\">\n" + "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"mainConnectionID\" type=\"q\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ + "<method name=\"disconnect\">\n" + "<arg name=\"mainConnectionID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ + "<method name=\"setVolume\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"volume\" type=\"n\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ + "<method name=\"volumeStep\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"volStep\" type=\"n\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ + "<method name=\"setSinkMuteState\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"muteState\" type=\"i\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + "<method name=\"setMainSinkSoundProperty\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"soundProperty\" type=\"(qn)\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + "<method name=\"setMainSourceSoundProperty\">\n" + "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"soundProperty\" type=\"(qn)\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ + "<method name=\"setSystemProperty\">\n" + "<arg name=\"property\" type=\"(qn)\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + "<method name=\"getListMainConnections\">\n" + "<arg name=\"listConnections\" type=\"a(qqqni)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + "<method name=\"getListMainSinks\">\n" + "<arg name=\"listMainSinks\" type=\"a(qs(iq)niq)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + "<method name=\"getListMainSources\">\n" + "<arg name=\"listMainSources\" type=\"a(qs(iq)q)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + */ + "<method name=\"getListMainSinkSoundProperties\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"listSoundProperties\" type=\"a(qn)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + "<method name=\"getListMainSourceSoundProperties\">\n" + "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"listSourceProperties\" type=\"a(qn)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + "<method name=\"getListSourceClasses\">\n" + "<arg name=\"listSourceClasses\" type=\"a(qsa(qn))\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + */ + "<method name=\"getListSinkClasses\">\n" + "<arg name=\"listSinkClasses\" type=\"a(qsa(qn))\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + "<method name=\"getListSystemProperties\">\n" + "<arg name=\"listSystemProperties\" type=\"a(qn)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ + "<method name=\"getTimingInformation\">\n" + "<arg name=\"mainConnectionID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"delay\" type=\"n\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ + "<method name=\"getListMainSinkNotificationConfigurations\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"listMainNotificationConfigurations\" type=\"a(qin)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ + "<method name=\"getListMainSourceNotificationConfigurations\">\n" + "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"listMainNotificationConfigurations\" type=\"a(qin)\" direction=\"out\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ + "<method name=\"setMainSinkNotificationConfiguration\">\n" + "<arg name=\"sinkID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ + "<method name=\"setMainSourceNotificationConfiguration\">\n" + "<arg name=\"sourceID\" type=\"q\" direction=\"in\" />\n" + "<arg name=\"mainNotificationConfiguration\" type=\"(qin)\" direction=\"in\" />\n" + "<arg name=\"error\" type=\"i\" direction=\"out\" />\n" + "</method>\n" + + ; + return introspectionData.c_str(); +} + +CommonAPI::DBus::DBusGetAttributeStubDispatcher< + CommandControlStub, + CommonAPI::Version + > CommandControlDBusStubAdapterInternal::getCommandControlInterfaceVersionStubDispatcher(&CommandControlStub::getInterfaceVersion, "uu"); + + + +/** + * connects a source to sink +(at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t, am_sinkID_t>, + std::tuple<am_mainConnectionID_t, am_Error_e> + > CommandControlDBusStubAdapterInternal::connectStubDispatcher(&CommandControlStub::connect, "qi"); +/** + * disconnects a mainConnection +(at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_mainConnectionID_t>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::disconnectStubDispatcher(&CommandControlStub::disconnect, "i"); +/** + * sets the volume for a sink +(at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_mainVolume_t>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setVolumeStubDispatcher(&CommandControlStub::setVolume, "i"); +/** + * This function is used to increment or decrement the current volume for a + * sink. +(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, int16_t>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::volumeStepStubDispatcher(&CommandControlStub::volumeStep, "i"); +/** + * sets the mute state of a sink +(at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_MuteState_e>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setSinkMuteStateStubDispatcher(&CommandControlStub::setSinkMuteState, "i"); +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_MainSoundProperty_s>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setMainSinkSoundPropertyStubDispatcher(&CommandControlStub::setMainSinkSoundProperty, "i"); +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t, am_MainSoundProperty_s>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setMainSourceSoundPropertyStubDispatcher(&CommandControlStub::setMainSourceSoundProperty, "i"); +/** + * is used to set a specific system property. +(at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_SystemProperty_s>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setSystemPropertyStubDispatcher(&CommandControlStub::setSystemProperty, "i"); +/** + * returns the actual list of MainConnections +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_MainConnection_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainConnectionsStubDispatcher(&CommandControlStub::getListMainConnections, "a(qqqni)i"); +/** + * returns the actual list of Sinks +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SinkType_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainSinksStubDispatcher(&CommandControlStub::getListMainSinks, "a(qs(iq)niq)i"); +/** + * returns the actual list of Sources +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SourceType_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainSourcesStubDispatcher(&CommandControlStub::getListMainSources, "a(qs(iq)q)i"); +/** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair +(at)return E_OK on + * success, E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t>, + std::tuple<am_MainSoundProperty_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainSinkSoundPropertiesStubDispatcher(&CommandControlStub::getListMainSinkSoundProperties, "a(qn)i"); +/** + * This is used to retrieve all source sound properties related to a + * source. +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t>, + std::tuple<am_MainSoundProperty_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainSourceSoundPropertiesStubDispatcher(&CommandControlStub::getListMainSourceSoundProperties, "a(qn)i"); +/** + * This is used to retrieve SourceClass Information of all source classes + * +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SourceClass_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListSourceClassesStubDispatcher(&CommandControlStub::getListSourceClasses, "a(qsa(qn))i"); +/** + * This is used to retrieve SinkClass Information of all sink classes +(at)return + * E_OK on success, E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SinkClass_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListSinkClassesStubDispatcher(&CommandControlStub::getListSinkClasses, "a(qsa(qn))i"); +/** + * Retrieves a complete list of all systemProperties. +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SystemProperty_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListSystemPropertiesStubDispatcher(&CommandControlStub::getListSystemProperties, "a(qn)i"); +/** + * returns the delay in ms that the audiopath for the given mainConnection + * has +(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_mainConnectionID_t>, + std::tuple<am_timeSync_t, am_Error_e> + > CommandControlDBusStubAdapterInternal::getTimingInformationStubDispatcher(&CommandControlStub::getTimingInformation, "ni"); +/** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t>, + std::tuple<am_NotificationConfiguration_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainSinkNotificationConfigurationsStubDispatcher(&CommandControlStub::getListMainSinkNotificationConfigurations, "a(qin)i"); +/** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t>, + std::tuple<am_NotificationConfiguration_L, am_Error_e> + > CommandControlDBusStubAdapterInternal::getListMainSourceNotificationConfigurationsStubDispatcher(&CommandControlStub::getListMainSourceNotificationConfigurations, "a(qin)i"); +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_NotificationConfiguration_s>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setMainSinkNotificationConfigurationStubDispatcher(&CommandControlStub::setMainSinkNotificationConfiguration, "i"); +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ +CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t, am_NotificationConfiguration_s>, + std::tuple<am_Error_e> + > CommandControlDBusStubAdapterInternal::setMainSourceNotificationConfigurationStubDispatcher(&CommandControlStub::setMainSourceNotificationConfiguration, "i"); + + + +/** + * Callback that is called when the number of connections change + */ +void CommandControlDBusStubAdapterInternal::fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_MainConnectionType_s>> + ::sendSignal( + *this, + "newMainConnection", + "(qqqni)", + mainConnection + ); +} +/** + * Callback that is called when the number of connections change + */ +void CommandControlDBusStubAdapterInternal::fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t>> + ::sendSignal( + *this, + "removedMainConnection", + "q", + mainConnection + ); +} +/** + * Callback that is called when the number of sinks change + */ +void CommandControlDBusStubAdapterInternal::fireNewSinkEvent(const am_SinkType_s& sink) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_SinkType_s>> + ::sendSignal( + *this, + "newSink", + "(qs(iq)niq)", + sink + ); +} +/** + * Callback that is called when the number of sinks change + */ +void CommandControlDBusStubAdapterInternal::fireRemovedSinkEvent(const am_sinkID_t& sinkID) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t>> + ::sendSignal( + *this, + "removedSink", + "q", + sinkID + ); +} +/** + * Callback that is called when the number of sources change + */ +void CommandControlDBusStubAdapterInternal::fireNewSourceEvent(const am_SourceType_s& source) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_SourceType_s>> + ::sendSignal( + *this, + "newSource", + "(qs(iq)q)", + source + ); +} +/** + * Callback that is called when the number of sources change + */ +void CommandControlDBusStubAdapterInternal::fireRemovedSourceEvent(const am_sourceID_t& source) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t>> + ::sendSignal( + *this, + "removedSource", + "q", + source + ); +} +/** + * this callback is fired if the number of sink classes changed + */ +void CommandControlDBusStubAdapterInternal::fireNumberOfSinkClassesChangedEvent() { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<>> + ::sendSignal( + *this, + "numberOfSinkClassesChanged", + "" + ); +} +/** + * this callback is fired if the number of source classes changed + */ +void CommandControlDBusStubAdapterInternal::fireNumberOfSourceClassesChangedEvent() { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<>> + ::sendSignal( + *this, + "numberOfSourceClassesChanged", + "" + ); +} +/** + * This callback is called when the ConnectionState of a connection changed. + */ +void CommandControlDBusStubAdapterInternal::fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_ConnectionState_e>> + ::sendSignal( + *this, + "mainConnectionStateChanged", + "qi", + connectionID, connectionState + ); +} +/** + * this callback indicates that a sinkSoundProperty has changed. + */ +void CommandControlDBusStubAdapterInternal::fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MainSoundProperty_s>> + ::sendSignal( + *this, + "mainSinkSoundPropertyChanged", + "q(qn)", + sinkID, soundProperty + ); +} +/** + * this callback indicates that a sourceSoundProperty has changed. + */ +void CommandControlDBusStubAdapterInternal::fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_MainSoundProperty_s>> + ::sendSignal( + *this, + "mainSourceSoundPropertyChanged", + "q(qn)", + sourceID, soundProperty + ); +} +/** + * this callback is called when the availability of a sink has changed + */ +void CommandControlDBusStubAdapterInternal::fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_Availability_s>> + ::sendSignal( + *this, + "sinkAvailabilityChanged", + "q(iq)", + sinkID, availability + ); +} +/** + * this callback is called when the availability of source has changed. + */ +void CommandControlDBusStubAdapterInternal::fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_Availability_s>> + ::sendSignal( + *this, + "sourceAvailabilityChanged", + "q(iq)", + sourceID, availability + ); +} +/** + * this callback indicates a volume change on the indicated sink + */ +void CommandControlDBusStubAdapterInternal::fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_mainVolume_t>> + ::sendSignal( + *this, + "volumeChanged", + "qn", + sinkID, volume + ); +} +/** + * this callback indicates a mute state change on a sink. + */ +void CommandControlDBusStubAdapterInternal::fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_MuteState_e>> + ::sendSignal( + *this, + "sinkMuteStateChanged", + "qi", + sinkID, muteState + ); +} +/** + * is fired if a systemProperty changed + */ +void CommandControlDBusStubAdapterInternal::fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_SystemProperty_s>> + ::sendSignal( + *this, + "systemPropertyChanged", + "(qn)", + systemProperty + ); +} +/** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ +void CommandControlDBusStubAdapterInternal::fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_mainConnectionID_t, am_timeSync_t>> + ::sendSignal( + *this, + "timingInformationChanged", + "qn", + mainConnectionID, time + ); +} +/** + * This callback is called when a sink is updated. + */ +void CommandControlDBusStubAdapterInternal::fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_sinkClass_t, am_MainSoundProperty_L>> + ::sendSignal( + *this, + "sinkUpdated", + "qqa(qn)", + sinkID, sinkClassID, listMainSoundProperties + ); +} +/** + * This callback is called when a source is updated. + */ +void CommandControlDBusStubAdapterInternal::fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_sourceClass_t, am_MainSoundProperty_L>> + ::sendSignal( + *this, + "sourceUpdated", + "qqa(qn)", + sourceID, sourceClassID, listMainSoundProperties + ); +} +/** + * This callback is called when a notificated value of a sink changes. + */ +void CommandControlDBusStubAdapterInternal::fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationPayload_s>> + ::sendSignal( + *this, + "sinkNotification", + "q(qn)", + sinkID, notification + ); +} +/** + * This callback is called when a notifcated value of a source changes. + */ +void CommandControlDBusStubAdapterInternal::fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationPayload_s>> + ::sendSignal( + *this, + "sourceNotification", + "q(qn)", + sourceID, notification + ); +} +/** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ +void CommandControlDBusStubAdapterInternal::fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sinkID_t, am_NotificationConfiguration_s>> + ::sendSignal( + *this, + "mainSinkNotificationConfigurationChanged", + "q(qin)", + sinkID, mainNotificationConfiguration + ); +} +/** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ +void CommandControlDBusStubAdapterInternal::fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) { + CommonAPI::DBus::DBusStubSignalHelper<CommonAPI::DBus::DBusSerializableArguments<am_sourceID_t, am_NotificationConfiguration_s>> + ::sendSignal( + *this, + "mainSourceNotificationConfigurationChanged", + "q(qin)", + sourceID, mainNotificationConfiguration + ); +} + + +const CommandControlDBusStubAdapterHelper::StubDispatcherTable& CommandControlDBusStubAdapterInternal::getStubDispatcherTable() { + return stubDispatcherTable_; +} + +const CommonAPI::DBus::StubAttributeTable& CommandControlDBusStubAdapterInternal::getStubAttributeTable() { + return stubAttributeTable_; +} + +CommandControlDBusStubAdapterInternal::CommandControlDBusStubAdapterInternal( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& dbusInterfaceName, + const std::string& dbusBusName, + const std::string& dbusObjectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection, + const std::shared_ptr<CommonAPI::StubBase>& stub): + CommonAPI::DBus::DBusStubAdapter( + factory, + commonApiAddress, + dbusInterfaceName, + dbusBusName, + dbusObjectPath, + dbusConnection, + false), + CommandControlDBusStubAdapterHelper( + factory, + commonApiAddress, + dbusInterfaceName, + dbusBusName, + dbusObjectPath, + dbusConnection, + std::dynamic_pointer_cast<CommandControlStub>(stub), + false), + stubDispatcherTable_({ + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ + { { "connect", "qq" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::connectStubDispatcher }, + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ + { { "disconnect", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::disconnectStubDispatcher }, + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ + { { "setVolume", "qn" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setVolumeStubDispatcher }, + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ + { { "volumeStep", "qn" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::volumeStepStubDispatcher }, + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ + { { "setSinkMuteState", "qi" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setSinkMuteStateStubDispatcher }, + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + { { "setMainSinkSoundProperty", "q(qn)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSinkSoundPropertyStubDispatcher }, + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + { { "setMainSourceSoundProperty", "q(qn)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSourceSoundPropertyStubDispatcher }, + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ + { { "setSystemProperty", "(qn)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setSystemPropertyStubDispatcher }, + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + { { "getListMainConnections", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainConnectionsStubDispatcher }, + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + { { "getListMainSinks", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSinksStubDispatcher }, + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + { { "getListMainSources", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSourcesStubDispatcher }, + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + */ + { { "getListMainSinkSoundProperties", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSinkSoundPropertiesStubDispatcher }, + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + { { "getListMainSourceSoundProperties", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSourceSoundPropertiesStubDispatcher }, + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + { { "getListSourceClasses", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListSourceClassesStubDispatcher }, + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + */ + { { "getListSinkClasses", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListSinkClassesStubDispatcher }, + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + { { "getListSystemProperties", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListSystemPropertiesStubDispatcher }, + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ + { { "getTimingInformation", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getTimingInformationStubDispatcher }, + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ + { { "getListMainSinkNotificationConfigurations", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSinkNotificationConfigurationsStubDispatcher }, + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ + { { "getListMainSourceNotificationConfigurations", "q" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getListMainSourceNotificationConfigurationsStubDispatcher }, + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ + { { "setMainSinkNotificationConfiguration", "q(qin)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSinkNotificationConfigurationStubDispatcher }, + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ + { { "setMainSourceNotificationConfiguration", "q(qin)" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::setMainSourceNotificationConfigurationStubDispatcher } + }), + stubAttributeTable_() { + + stubDispatcherTable_.insert({ { "getInterfaceVersion", "" }, &org::genivi::am::CommandControlDBusStubAdapterInternal::getCommandControlInterfaceVersionStubDispatcher }); +} + +const bool CommandControlDBusStubAdapterInternal::hasFreedesktopProperties() { + return false; +} + +} // namespace am +} // namespace genivi +} // namespace org diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h new file mode 100644 index 0000000..0909211 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlDBusStubAdapter.h @@ -0,0 +1,422 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_DBUS_STUB_ADAPTER_H_ +#define ORG_GENIVI_AM_Command_Control_DBUS_STUB_ADAPTER_H_ + +#include <org/genivi/am/CommandControlStub.h> + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/DBus/DBusStubAdapterHelper.h> +#include <CommonAPI/DBus/DBusStubAdapter.h> +#include <CommonAPI/DBus/DBusFactory.h> +#include <CommonAPI/DBus/DBusServicePublisher.h> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace org { +namespace genivi { +namespace am { + +typedef CommonAPI::DBus::DBusStubAdapterHelper<CommandControlStub> CommandControlDBusStubAdapterHelper; + +class CommandControlDBusStubAdapterInternal: public virtual CommandControlStubAdapter, public CommandControlDBusStubAdapterHelper { + public: + CommandControlDBusStubAdapterInternal( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& dbusInterfaceName, + const std::string& dbusBusName, + const std::string& dbusObjectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection, + const std::shared_ptr<CommonAPI::StubBase>& stub); + + ~CommandControlDBusStubAdapterInternal(); + + virtual const bool hasFreedesktopProperties(); + + + /** + * Callback that is called when the number of connections change + */ + void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection); + /** + * Callback that is called when the number of connections change + */ + void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection); + /** + * Callback that is called when the number of sinks change + */ + void fireNewSinkEvent(const am_SinkType_s& sink); + /** + * Callback that is called when the number of sinks change + */ + void fireRemovedSinkEvent(const am_sinkID_t& sinkID); + /** + * Callback that is called when the number of sources change + */ + void fireNewSourceEvent(const am_SourceType_s& source); + /** + * Callback that is called when the number of sources change + */ + void fireRemovedSourceEvent(const am_sourceID_t& source); + /** + * this callback is fired if the number of sink classes changed + */ + void fireNumberOfSinkClassesChangedEvent(); + /** + * this callback is fired if the number of source classes changed + */ + void fireNumberOfSourceClassesChangedEvent(); + /** + * This callback is called when the ConnectionState of a connection changed. + */ + void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState); + /** + * this callback indicates that a sinkSoundProperty has changed. + */ + void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty); + /** + * this callback indicates that a sourceSoundProperty has changed. + */ + void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty); + /** + * this callback is called when the availability of a sink has changed + */ + void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability); + /** + * this callback is called when the availability of source has changed. + */ + void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability); + /** + * this callback indicates a volume change on the indicated sink + */ + void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume); + /** + * this callback indicates a mute state change on a sink. + */ + void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState); + /** + * is fired if a systemProperty changed + */ + void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty); + /** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ + void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time); + /** + * This callback is called when a sink is updated. + */ + void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties); + /** + * This callback is called when a source is updated. + */ + void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties); + /** + * This callback is called when a notificated value of a sink changes. + */ + void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification); + /** + * This callback is called when a notifcated value of a source changes. + */ + void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification); + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration); + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration); + + + const CommandControlDBusStubAdapterHelper::StubDispatcherTable& getStubDispatcherTable(); + const CommonAPI::DBus::StubAttributeTable& getStubAttributeTable(); + + void deactivateManagedInstances(); + + +static CommonAPI::DBus::DBusGetAttributeStubDispatcher< + CommandControlStub, + CommonAPI::Version + > getCommandControlInterfaceVersionStubDispatcher; + + + +/** + * connects a source to sink +(at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t, am_sinkID_t>, + std::tuple<am_mainConnectionID_t, am_Error_e> + > connectStubDispatcher; +/** + * disconnects a mainConnection +(at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_mainConnectionID_t>, + std::tuple<am_Error_e> + > disconnectStubDispatcher; +/** + * sets the volume for a sink +(at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_mainVolume_t>, + std::tuple<am_Error_e> + > setVolumeStubDispatcher; +/** + * This function is used to increment or decrement the current volume for a + * sink. +(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, int16_t>, + std::tuple<am_Error_e> + > volumeStepStubDispatcher; +/** + * sets the mute state of a sink +(at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_MuteState_e>, + std::tuple<am_Error_e> + > setSinkMuteStateStubDispatcher; +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_MainSoundProperty_s>, + std::tuple<am_Error_e> + > setMainSinkSoundPropertyStubDispatcher; +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t, am_MainSoundProperty_s>, + std::tuple<am_Error_e> + > setMainSourceSoundPropertyStubDispatcher; +/** + * is used to set a specific system property. +(at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_SystemProperty_s>, + std::tuple<am_Error_e> + > setSystemPropertyStubDispatcher; +/** + * returns the actual list of MainConnections +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_MainConnection_L, am_Error_e> + > getListMainConnectionsStubDispatcher; +/** + * returns the actual list of Sinks +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SinkType_L, am_Error_e> + > getListMainSinksStubDispatcher; +/** + * returns the actual list of Sources +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SourceType_L, am_Error_e> + > getListMainSourcesStubDispatcher; +/** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair +(at)return E_OK on + * success, E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t>, + std::tuple<am_MainSoundProperty_L, am_Error_e> + > getListMainSinkSoundPropertiesStubDispatcher; +/** + * This is used to retrieve all source sound properties related to a + * source. +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t>, + std::tuple<am_MainSoundProperty_L, am_Error_e> + > getListMainSourceSoundPropertiesStubDispatcher; +/** + * This is used to retrieve SourceClass Information of all source classes + * +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SourceClass_L, am_Error_e> + > getListSourceClassesStubDispatcher; +/** + * This is used to retrieve SinkClass Information of all sink classes +(at)return + * E_OK on success, E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SinkClass_L, am_Error_e> + > getListSinkClassesStubDispatcher; +/** + * Retrieves a complete list of all systemProperties. +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<>, + std::tuple<am_SystemProperty_L, am_Error_e> + > getListSystemPropertiesStubDispatcher; +/** + * returns the delay in ms that the audiopath for the given mainConnection + * has +(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_mainConnectionID_t>, + std::tuple<am_timeSync_t, am_Error_e> + > getTimingInformationStubDispatcher; +/** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t>, + std::tuple<am_NotificationConfiguration_L, am_Error_e> + > getListMainSinkNotificationConfigurationsStubDispatcher; +/** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t>, + std::tuple<am_NotificationConfiguration_L, am_Error_e> + > getListMainSourceNotificationConfigurationsStubDispatcher; +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sinkID_t, am_NotificationConfiguration_s>, + std::tuple<am_Error_e> + > setMainSinkNotificationConfigurationStubDispatcher; +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + CommandControlStub, + std::tuple<am_sourceID_t, am_NotificationConfiguration_s>, + std::tuple<am_Error_e> + > setMainSourceNotificationConfigurationStubDispatcher; + + + + + protected: + virtual const char* getMethodsDBusIntrospectionXmlData() const; + + private: + CommandControlDBusStubAdapterHelper::StubDispatcherTable stubDispatcherTable_; + CommonAPI::DBus::StubAttributeTable stubAttributeTable_; +}; + +class CommandControlDBusStubAdapter: public CommandControlDBusStubAdapterInternal, public std::enable_shared_from_this<CommandControlDBusStubAdapter> { +public: + CommandControlDBusStubAdapter( + const std::shared_ptr<CommonAPI::DBus::DBusFactory>& factory, + const std::string& commonApiAddress, + const std::string& dbusInterfaceName, + const std::string& dbusBusName, + const std::string& dbusObjectPath, + const std::shared_ptr<CommonAPI::DBus::DBusProxyConnection>& dbusConnection, + const std::shared_ptr<CommonAPI::StubBase>& stub) : + CommonAPI::DBus::DBusStubAdapter( + factory, + commonApiAddress, + dbusInterfaceName, + dbusBusName, + dbusObjectPath, + dbusConnection, + false), + CommandControlDBusStubAdapterInternal( + factory, + commonApiAddress, + dbusInterfaceName, + dbusBusName, + dbusObjectPath, + dbusConnection, + stub) { } +}; + +} // namespace am +} // namespace genivi +} // namespace org + +#endif // ORG_GENIVI_AM_Command_Control_DBUS_STUB_ADAPTER_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h new file mode 100644 index 0000000..03e6a62 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxy.h @@ -0,0 +1,1194 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_PROXY_H_ +#define ORG_GENIVI_AM_Command_Control_PROXY_H_ + +#include "CommandControlProxyBase.h" + + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace org { +namespace genivi { +namespace am { + +template <typename ... _AttributeExtensions> +class CommandControlProxy: virtual public CommandControl, virtual public CommandControlProxyBase +, public _AttributeExtensions... { +public: + CommandControlProxy(std::shared_ptr<CommonAPI::Proxy> delegate); + ~CommandControlProxy(); + + typedef CommandControl InterfaceType; + + + + /** + * Callback that is called when the number of connections change + */ + /** + * Returns the wrapper class that provides access to the broadcast newMainConnection. + */ + virtual NewMainConnectionEvent& getNewMainConnectionEvent() { + return delegate_->getNewMainConnectionEvent(); + } + /** + * Callback that is called when the number of connections change + */ + /** + * Returns the wrapper class that provides access to the broadcast removedMainConnection. + */ + virtual RemovedMainConnectionEvent& getRemovedMainConnectionEvent() { + return delegate_->getRemovedMainConnectionEvent(); + } + /** + * Callback that is called when the number of sinks change + */ + /** + * Returns the wrapper class that provides access to the broadcast newSink. + */ + virtual NewSinkEvent& getNewSinkEvent() { + return delegate_->getNewSinkEvent(); + } + /** + * Callback that is called when the number of sinks change + */ + /** + * Returns the wrapper class that provides access to the broadcast removedSink. + */ + virtual RemovedSinkEvent& getRemovedSinkEvent() { + return delegate_->getRemovedSinkEvent(); + } + /** + * Callback that is called when the number of sources change + */ + /** + * Returns the wrapper class that provides access to the broadcast newSource. + */ + virtual NewSourceEvent& getNewSourceEvent() { + return delegate_->getNewSourceEvent(); + } + /** + * Callback that is called when the number of sources change + */ + /** + * Returns the wrapper class that provides access to the broadcast removedSource. + */ + virtual RemovedSourceEvent& getRemovedSourceEvent() { + return delegate_->getRemovedSourceEvent(); + } + /** + * this callback is fired if the number of sink classes changed + */ + /** + * Returns the wrapper class that provides access to the broadcast numberOfSinkClassesChanged. + */ + virtual NumberOfSinkClassesChangedEvent& getNumberOfSinkClassesChangedEvent() { + return delegate_->getNumberOfSinkClassesChangedEvent(); + } + /** + * this callback is fired if the number of source classes changed + */ + /** + * Returns the wrapper class that provides access to the broadcast numberOfSourceClassesChanged. + */ + virtual NumberOfSourceClassesChangedEvent& getNumberOfSourceClassesChangedEvent() { + return delegate_->getNumberOfSourceClassesChangedEvent(); + } + /** + * This callback is called when the ConnectionState of a connection changed. + */ + /** + * Returns the wrapper class that provides access to the broadcast mainConnectionStateChanged. + */ + virtual MainConnectionStateChangedEvent& getMainConnectionStateChangedEvent() { + return delegate_->getMainConnectionStateChangedEvent(); + } + /** + * this callback indicates that a sinkSoundProperty has changed. + */ + /** + * Returns the wrapper class that provides access to the broadcast mainSinkSoundPropertyChanged. + */ + virtual MainSinkSoundPropertyChangedEvent& getMainSinkSoundPropertyChangedEvent() { + return delegate_->getMainSinkSoundPropertyChangedEvent(); + } + /** + * this callback indicates that a sourceSoundProperty has changed. + */ + /** + * Returns the wrapper class that provides access to the broadcast mainSourceSoundPropertyChanged. + */ + virtual MainSourceSoundPropertyChangedEvent& getMainSourceSoundPropertyChangedEvent() { + return delegate_->getMainSourceSoundPropertyChangedEvent(); + } + /** + * this callback is called when the availability of a sink has changed + */ + /** + * Returns the wrapper class that provides access to the broadcast sinkAvailabilityChanged. + */ + virtual SinkAvailabilityChangedEvent& getSinkAvailabilityChangedEvent() { + return delegate_->getSinkAvailabilityChangedEvent(); + } + /** + * this callback is called when the availability of source has changed. + */ + /** + * Returns the wrapper class that provides access to the broadcast sourceAvailabilityChanged. + */ + virtual SourceAvailabilityChangedEvent& getSourceAvailabilityChangedEvent() { + return delegate_->getSourceAvailabilityChangedEvent(); + } + /** + * this callback indicates a volume change on the indicated sink + */ + /** + * Returns the wrapper class that provides access to the broadcast volumeChanged. + */ + virtual VolumeChangedEvent& getVolumeChangedEvent() { + return delegate_->getVolumeChangedEvent(); + } + /** + * this callback indicates a mute state change on a sink. + */ + /** + * Returns the wrapper class that provides access to the broadcast sinkMuteStateChanged. + */ + virtual SinkMuteStateChangedEvent& getSinkMuteStateChangedEvent() { + return delegate_->getSinkMuteStateChangedEvent(); + } + /** + * is fired if a systemProperty changed + */ + /** + * Returns the wrapper class that provides access to the broadcast systemPropertyChanged. + */ + virtual SystemPropertyChangedEvent& getSystemPropertyChangedEvent() { + return delegate_->getSystemPropertyChangedEvent(); + } + /** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ + /** + * Returns the wrapper class that provides access to the broadcast timingInformationChanged. + */ + virtual TimingInformationChangedEvent& getTimingInformationChangedEvent() { + return delegate_->getTimingInformationChangedEvent(); + } + /** + * This callback is called when a sink is updated. + */ + /** + * Returns the wrapper class that provides access to the broadcast sinkUpdated. + */ + virtual SinkUpdatedEvent& getSinkUpdatedEvent() { + return delegate_->getSinkUpdatedEvent(); + } + /** + * This callback is called when a source is updated. + */ + /** + * Returns the wrapper class that provides access to the broadcast sourceUpdated. + */ + virtual SourceUpdatedEvent& getSourceUpdatedEvent() { + return delegate_->getSourceUpdatedEvent(); + } + /** + * This callback is called when a notificated value of a sink changes. + */ + /** + * Returns the wrapper class that provides access to the broadcast sinkNotification. + */ + virtual SinkNotificationEvent& getSinkNotificationEvent() { + return delegate_->getSinkNotificationEvent(); + } + /** + * This callback is called when a notifcated value of a source changes. + */ + /** + * Returns the wrapper class that provides access to the broadcast sourceNotification. + */ + virtual SourceNotificationEvent& getSourceNotificationEvent() { + return delegate_->getSourceNotificationEvent(); + } + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + /** + * Returns the wrapper class that provides access to the broadcast mainSinkNotificationConfigurationChanged. + */ + virtual MainSinkNotificationConfigurationChangedEvent& getMainSinkNotificationConfigurationChangedEvent() { + return delegate_->getMainSinkNotificationConfigurationChangedEvent(); + } + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + /** + * Returns the wrapper class that provides access to the broadcast mainSourceNotificationConfigurationChanged. + */ + virtual MainSourceNotificationConfigurationChangedEvent& getMainSourceNotificationConfigurationChangedEvent() { + return delegate_->getMainSourceNotificationConfigurationChangedEvent(); + } + + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + * + * Calls connect with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error); + /** + * Calls connect with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback); + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + * + * Calls disconnect with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls disconnect with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback); + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + * + * Calls setVolume with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setVolume with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback); + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + * + * Calls volumeStep with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls volumeStep with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback); + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + * + * Calls setSinkMuteState with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setSinkMuteState with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback); + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + * + * Calls setMainSinkSoundProperty with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setMainSinkSoundProperty with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback); + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + * + * Calls setMainSourceSoundProperty with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setMainSourceSoundProperty with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback); + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + * + * Calls setSystemProperty with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setSystemProperty with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback); + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + * + * Calls getListMainConnections with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error); + /** + * Calls getListMainConnections with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback); + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + * + * Calls getListMainSinks with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error); + /** + * Calls getListMainSinks with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainSinksAsync(GetListMainSinksAsyncCallback callback); + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + * + * Calls getListMainSources with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error); + /** + * Calls getListMainSources with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback); + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + * + * Calls getListMainSinkSoundProperties with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error); + /** + * Calls getListMainSinkSoundProperties with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback); + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + * + * Calls getListMainSourceSoundProperties with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error); + /** + * Calls getListMainSourceSoundProperties with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback); + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + * + * Calls getListSourceClasses with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error); + /** + * Calls getListSourceClasses with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback); + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + * + * Calls getListSinkClasses with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error); + /** + * Calls getListSinkClasses with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback); + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + * + * Calls getListSystemProperties with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error); + /** + * Calls getListSystemProperties with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback); + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + * + * Calls getTimingInformation with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error); + /** + * Calls getTimingInformation with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback); + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + * + * Calls getListMainSinkNotificationConfigurations with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + /** + * Calls getListMainSinkNotificationConfigurations with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback); + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + * + * Calls getListMainSourceNotificationConfigurations with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + /** + * Calls getListMainSourceNotificationConfigurations with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback); + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + * + * Calls setMainSinkNotificationConfiguration with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setMainSinkNotificationConfiguration with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback); + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + * + * Calls setMainSourceNotificationConfiguration with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error); + /** + * Calls setMainSourceNotificationConfiguration with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback); + + + /** + * Returns the CommonAPI address of the remote partner this proxy communicates with. + */ + virtual std::string getAddress() const; + + /** + * Returns the domain of the remote partner this proxy communicates with. + */ + virtual const std::string& getDomain() const; + + /** + * Returns the service ID of the remote partner this proxy communicates with. + */ + virtual const std::string& getServiceId() const; + + /** + * Returns the instance ID of the remote partner this proxy communicates with. + */ + virtual const std::string& getInstanceId() const; + + /** + * Returns true if the remote partner for this proxy is currently known to be available. + */ + virtual bool isAvailable() const; + + /** + * Returns true if the remote partner for this proxy is available. + */ + virtual bool isAvailableBlocking() const; + + /** + * Returns the wrapper class that is used to (de-)register for notifications about + * the availability of the remote partner of this proxy. + */ + virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent(); + + /** + * Returns the wrapper class that is used to access version information of the remote + * partner of this proxy. + */ + virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute(); + + private: + std::shared_ptr<CommandControlProxyBase> delegate_; +}; + +#ifdef WIN32 + typedef CommandControlProxy<CommonAPI::WINDummyAttributeExtension<CommonAPI::WINDummyAttribute>> CommandControlProxyDefault; +#else + typedef CommandControlProxy<> CommandControlProxyDefault; +#endif + + +// +// CommandControlProxy Implementation +// +template <typename ... _AttributeExtensions> +CommandControlProxy<_AttributeExtensions...>::CommandControlProxy(std::shared_ptr<CommonAPI::Proxy> delegate): + _AttributeExtensions(*(std::dynamic_pointer_cast<CommandControlProxyBase>(delegate)))..., + delegate_(std::dynamic_pointer_cast<CommandControlProxyBase>(delegate)) { +} + +template <typename ... _AttributeExtensions> +CommandControlProxy<_AttributeExtensions...>::~CommandControlProxy() { +} + +/** + * connects a source to sink +(at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) { + delegate_->connect(sourceID, sinkID, callStatus, mainConnectionID, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) { + return delegate_->connectAsync(sourceID, sinkID, callback); +} +/** + * disconnects a mainConnection +(at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->disconnect(mainConnectionID, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) { + return delegate_->disconnectAsync(mainConnectionID, callback); +} +/** + * sets the volume for a sink +(at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setVolume(sinkID, volume, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) { + return delegate_->setVolumeAsync(sinkID, volume, callback); +} +/** + * This function is used to increment or decrement the current volume for a + * sink. +(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->volumeStep(sinkID, volStep, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback) { + return delegate_->volumeStepAsync(sinkID, volStep, callback); +} +/** + * sets the mute state of a sink +(at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setSinkMuteState(sinkID, muteState, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) { + return delegate_->setSinkMuteStateAsync(sinkID, muteState, callback); +} +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setMainSinkSoundProperty(sinkID, soundProperty, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) { + return delegate_->setMainSinkSoundPropertyAsync(sinkID, soundProperty, callback); +} +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setMainSourceSoundProperty(sourceID, soundProperty, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) { + return delegate_->setMainSourceSoundPropertyAsync(sourceID, soundProperty, callback); +} +/** + * is used to set a specific system property. +(at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setSystemProperty(property, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) { + return delegate_->setSystemPropertyAsync(property, callback); +} +/** + * returns the actual list of MainConnections +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) { + delegate_->getListMainConnections(callStatus, listConnections, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) { + return delegate_->getListMainConnectionsAsync(callback); +} +/** + * returns the actual list of Sinks +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) { + delegate_->getListMainSinks(callStatus, listMainSinks, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSinksAsync(GetListMainSinksAsyncCallback callback) { + return delegate_->getListMainSinksAsync(callback); +} +/** + * returns the actual list of Sources +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) { + delegate_->getListMainSources(callStatus, listMainSources, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) { + return delegate_->getListMainSourcesAsync(callback); +} +/** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair +(at)return E_OK on + * success, E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) { + delegate_->getListMainSinkSoundProperties(sinkID, callStatus, listSoundProperties, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) { + return delegate_->getListMainSinkSoundPropertiesAsync(sinkID, callback); +} +/** + * This is used to retrieve all source sound properties related to a + * source. +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) { + delegate_->getListMainSourceSoundProperties(sourceID, callStatus, listSourceProperties, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) { + return delegate_->getListMainSourceSoundPropertiesAsync(sourceID, callback); +} +/** + * This is used to retrieve SourceClass Information of all source classes + * +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) { + delegate_->getListSourceClasses(callStatus, listSourceClasses, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) { + return delegate_->getListSourceClassesAsync(callback); +} +/** + * This is used to retrieve SinkClass Information of all sink classes +(at)return + * E_OK on success, E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) { + delegate_->getListSinkClasses(callStatus, listSinkClasses, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) { + return delegate_->getListSinkClassesAsync(callback); +} +/** + * Retrieves a complete list of all systemProperties. +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) { + delegate_->getListSystemProperties(callStatus, listSystemProperties, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) { + return delegate_->getListSystemPropertiesAsync(callback); +} +/** + * returns the delay in ms that the audiopath for the given mainConnection + * has +(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) { + delegate_->getTimingInformation(mainConnectionID, callStatus, delay, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) { + return delegate_->getTimingInformationAsync(mainConnectionID, callback); +} +/** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + delegate_->getListMainSinkNotificationConfigurations(sinkID, callStatus, listMainNotificationConfigurations, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) { + return delegate_->getListMainSinkNotificationConfigurationsAsync(sinkID, callback); +} +/** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + delegate_->getListMainSourceNotificationConfigurations(sourceID, callStatus, listMainNotificationConfigurations, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) { + return delegate_->getListMainSourceNotificationConfigurationsAsync(sourceID, callback); +} +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setMainSinkNotificationConfiguration(sinkID, mainNotificationConfiguration, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) { + return delegate_->setMainSinkNotificationConfigurationAsync(sinkID, mainNotificationConfiguration, callback); +} +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ +template <typename ... _AttributeExtensions> +void CommandControlProxy<_AttributeExtensions...>::setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) { + delegate_->setMainSourceNotificationConfiguration(sourceID, mainNotificationConfiguration, callStatus, error); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> CommandControlProxy<_AttributeExtensions...>::setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) { + return delegate_->setMainSourceNotificationConfigurationAsync(sourceID, mainNotificationConfiguration, callback); +} + +template <typename ... _AttributeExtensions> +std::string CommandControlProxy<_AttributeExtensions...>::getAddress() const { + return delegate_->getAddress(); +} + +template <typename ... _AttributeExtensions> +const std::string& CommandControlProxy<_AttributeExtensions...>::getDomain() const { + return delegate_->getDomain(); +} + +template <typename ... _AttributeExtensions> +const std::string& CommandControlProxy<_AttributeExtensions...>::getServiceId() const { + return delegate_->getServiceId(); +} + +template <typename ... _AttributeExtensions> +const std::string& CommandControlProxy<_AttributeExtensions...>::getInstanceId() const { + return delegate_->getInstanceId(); +} + +template <typename ... _AttributeExtensions> +bool CommandControlProxy<_AttributeExtensions...>::isAvailable() const { + return delegate_->isAvailable(); +} + +template <typename ... _AttributeExtensions> +bool CommandControlProxy<_AttributeExtensions...>::isAvailableBlocking() const { + return delegate_->isAvailableBlocking(); +} + +template <typename ... _AttributeExtensions> +CommonAPI::ProxyStatusEvent& CommandControlProxy<_AttributeExtensions...>::getProxyStatusEvent() { + return delegate_->getProxyStatusEvent(); +} + +template <typename ... _AttributeExtensions> +CommonAPI::InterfaceVersionAttribute& CommandControlProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() { + return delegate_->getInterfaceVersionAttribute(); +} + + +} // namespace am +} // namespace genivi +} // namespace org + + +#endif // ORG_GENIVI_AM_Command_Control_PROXY_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h new file mode 100644 index 0000000..767b9e1 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlProxyBase.h @@ -0,0 +1,348 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_PROXY_BASE_H_ +#define ORG_GENIVI_AM_Command_Control_PROXY_BASE_H_ + +#include "CommandControl.h" + + +#include <org/genivi/am.h> + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/InputStream.h> +#include <CommonAPI/OutputStream.h> +#include <CommonAPI/SerializableStruct.h> +#include <cstdint> +#include <string> +#include <vector> + +#include <CommonAPI/Event.h> +#include <CommonAPI/Proxy.h> +#include <functional> +#include <future> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace org { +namespace genivi { +namespace am { + +class CommandControlProxyBase: virtual public CommonAPI::Proxy { + public: + typedef CommonAPI::Event<am_MainConnectionType_s> NewMainConnectionEvent; + typedef CommonAPI::Event<am_mainConnectionID_t> RemovedMainConnectionEvent; + typedef CommonAPI::Event<am_SinkType_s> NewSinkEvent; + typedef CommonAPI::Event<am_sinkID_t> RemovedSinkEvent; + typedef CommonAPI::Event<am_SourceType_s> NewSourceEvent; + typedef CommonAPI::Event<am_sourceID_t> RemovedSourceEvent; + typedef CommonAPI::Event<> NumberOfSinkClassesChangedEvent; + typedef CommonAPI::Event<> NumberOfSourceClassesChangedEvent; + typedef CommonAPI::Event<am_mainConnectionID_t, am_ConnectionState_e> MainConnectionStateChangedEvent; + typedef CommonAPI::Event<am_sinkID_t, am_MainSoundProperty_s> MainSinkSoundPropertyChangedEvent; + typedef CommonAPI::Event<am_sourceID_t, am_MainSoundProperty_s> MainSourceSoundPropertyChangedEvent; + typedef CommonAPI::Event<am_sinkID_t, am_Availability_s> SinkAvailabilityChangedEvent; + typedef CommonAPI::Event<am_sourceID_t, am_Availability_s> SourceAvailabilityChangedEvent; + typedef CommonAPI::Event<am_sinkID_t, am_mainVolume_t> VolumeChangedEvent; + typedef CommonAPI::Event<am_sinkID_t, am_MuteState_e> SinkMuteStateChangedEvent; + typedef CommonAPI::Event<am_SystemProperty_s> SystemPropertyChangedEvent; + typedef CommonAPI::Event<am_mainConnectionID_t, am_timeSync_t> TimingInformationChangedEvent; + typedef CommonAPI::Event<am_sinkID_t, am_sinkClass_t, am_MainSoundProperty_L> SinkUpdatedEvent; + typedef CommonAPI::Event<am_sourceID_t, am_sourceClass_t, am_MainSoundProperty_L> SourceUpdatedEvent; + typedef CommonAPI::Event<am_sinkID_t, am_NotificationPayload_s> SinkNotificationEvent; + typedef CommonAPI::Event<am_sourceID_t, am_NotificationPayload_s> SourceNotificationEvent; + typedef CommonAPI::Event<am_sinkID_t, am_NotificationConfiguration_s> MainSinkNotificationConfigurationChangedEvent; + typedef CommonAPI::Event<am_sourceID_t, am_NotificationConfiguration_s> MainSourceNotificationConfigurationChangedEvent; + + typedef std::function<void(const CommonAPI::CallStatus&, const am_mainConnectionID_t&, const am_Error_e&)> ConnectAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> DisconnectAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetVolumeAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> VolumeStepAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetSinkMuteStateAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSinkSoundPropertyAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSourceSoundPropertyAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetSystemPropertyAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_MainConnection_L&, const am_Error_e&)> GetListMainConnectionsAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_SinkType_L&, const am_Error_e&)> GetListMainSinksAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_SourceType_L&, const am_Error_e&)> GetListMainSourcesAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_MainSoundProperty_L&, const am_Error_e&)> GetListMainSinkSoundPropertiesAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_MainSoundProperty_L&, const am_Error_e&)> GetListMainSourceSoundPropertiesAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_SourceClass_L&, const am_Error_e&)> GetListSourceClassesAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_SinkClass_L&, const am_Error_e&)> GetListSinkClassesAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_SystemProperty_L&, const am_Error_e&)> GetListSystemPropertiesAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_timeSync_t&, const am_Error_e&)> GetTimingInformationAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_NotificationConfiguration_L&, const am_Error_e&)> GetListMainSinkNotificationConfigurationsAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_NotificationConfiguration_L&, const am_Error_e&)> GetListMainSourceNotificationConfigurationsAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSinkNotificationConfigurationAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const am_Error_e&)> SetMainSourceNotificationConfigurationAsyncCallback; + + + /** + * Callback that is called when the number of connections change + */ + virtual NewMainConnectionEvent& getNewMainConnectionEvent() = 0; + /** + * Callback that is called when the number of connections change + */ + virtual RemovedMainConnectionEvent& getRemovedMainConnectionEvent() = 0; + /** + * Callback that is called when the number of sinks change + */ + virtual NewSinkEvent& getNewSinkEvent() = 0; + /** + * Callback that is called when the number of sinks change + */ + virtual RemovedSinkEvent& getRemovedSinkEvent() = 0; + /** + * Callback that is called when the number of sources change + */ + virtual NewSourceEvent& getNewSourceEvent() = 0; + /** + * Callback that is called when the number of sources change + */ + virtual RemovedSourceEvent& getRemovedSourceEvent() = 0; + /** + * this callback is fired if the number of sink classes changed + */ + virtual NumberOfSinkClassesChangedEvent& getNumberOfSinkClassesChangedEvent() = 0; + /** + * this callback is fired if the number of source classes changed + */ + virtual NumberOfSourceClassesChangedEvent& getNumberOfSourceClassesChangedEvent() = 0; + /** + * This callback is called when the ConnectionState of a connection changed. + */ + virtual MainConnectionStateChangedEvent& getMainConnectionStateChangedEvent() = 0; + /** + * this callback indicates that a sinkSoundProperty has changed. + */ + virtual MainSinkSoundPropertyChangedEvent& getMainSinkSoundPropertyChangedEvent() = 0; + /** + * this callback indicates that a sourceSoundProperty has changed. + */ + virtual MainSourceSoundPropertyChangedEvent& getMainSourceSoundPropertyChangedEvent() = 0; + /** + * this callback is called when the availability of a sink has changed + */ + virtual SinkAvailabilityChangedEvent& getSinkAvailabilityChangedEvent() = 0; + /** + * this callback is called when the availability of source has changed. + */ + virtual SourceAvailabilityChangedEvent& getSourceAvailabilityChangedEvent() = 0; + /** + * this callback indicates a volume change on the indicated sink + */ + virtual VolumeChangedEvent& getVolumeChangedEvent() = 0; + /** + * this callback indicates a mute state change on a sink. + */ + virtual SinkMuteStateChangedEvent& getSinkMuteStateChangedEvent() = 0; + /** + * is fired if a systemProperty changed + */ + virtual SystemPropertyChangedEvent& getSystemPropertyChangedEvent() = 0; + /** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ + virtual TimingInformationChangedEvent& getTimingInformationChangedEvent() = 0; + /** + * This callback is called when a sink is updated. + */ + virtual SinkUpdatedEvent& getSinkUpdatedEvent() = 0; + /** + * This callback is called when a source is updated. + */ + virtual SourceUpdatedEvent& getSourceUpdatedEvent() = 0; + /** + * This callback is called when a notificated value of a sink changes. + */ + virtual SinkNotificationEvent& getSinkNotificationEvent() = 0; + /** + * This callback is called when a notifcated value of a source changes. + */ + virtual SourceNotificationEvent& getSourceNotificationEvent() = 0; + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + virtual MainSinkNotificationConfigurationChangedEvent& getMainSinkNotificationConfigurationChangedEvent() = 0; + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + virtual MainSourceNotificationConfigurationChangedEvent& getMainSourceNotificationConfigurationChangedEvent() = 0; + + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ + virtual void connect(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> connectAsync(const am_sourceID_t& sourceID, const am_sinkID_t& sinkID, ConnectAsyncCallback callback) = 0; + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ + virtual void disconnect(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> disconnectAsync(const am_mainConnectionID_t& mainConnectionID, DisconnectAsyncCallback callback) = 0; + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ + virtual void setVolume(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setVolumeAsync(const am_sinkID_t& sinkID, const am_mainVolume_t& volume, SetVolumeAsyncCallback callback) = 0; + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ + virtual void volumeStep(const am_sinkID_t& sinkID, const int16_t& volStep, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> volumeStepAsync(const am_sinkID_t& sinkID, const int16_t& volStep, VolumeStepAsyncCallback callback) = 0; + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ + virtual void setSinkMuteState(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setSinkMuteStateAsync(const am_sinkID_t& sinkID, const am_MuteState_e& muteState, SetSinkMuteStateAsyncCallback callback) = 0; + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + virtual void setMainSinkSoundProperty(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setMainSinkSoundPropertyAsync(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty, SetMainSinkSoundPropertyAsyncCallback callback) = 0; + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + virtual void setMainSourceSoundProperty(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setMainSourceSoundPropertyAsync(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty, SetMainSourceSoundPropertyAsyncCallback callback) = 0; + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ + virtual void setSystemProperty(const am_SystemProperty_s& property, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setSystemPropertyAsync(const am_SystemProperty_s& property, SetSystemPropertyAsyncCallback callback) = 0; + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + virtual void getListMainConnections(CommonAPI::CallStatus& callStatus, am_MainConnection_L& listConnections, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainConnectionsAsync(GetListMainConnectionsAsyncCallback callback) = 0; + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + virtual void getListMainSinks(CommonAPI::CallStatus& callStatus, am_SinkType_L& listMainSinks, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainSinksAsync(GetListMainSinksAsyncCallback callback) = 0; + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + virtual void getListMainSources(CommonAPI::CallStatus& callStatus, am_SourceType_L& listMainSources, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainSourcesAsync(GetListMainSourcesAsyncCallback callback) = 0; + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + */ + virtual void getListMainSinkSoundProperties(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainSinkSoundPropertiesAsync(const am_sinkID_t& sinkID, GetListMainSinkSoundPropertiesAsyncCallback callback) = 0; + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListMainSourceSoundProperties(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainSourceSoundPropertiesAsync(const am_sourceID_t& sourceID, GetListMainSourceSoundPropertiesAsyncCallback callback) = 0; + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListSourceClasses(CommonAPI::CallStatus& callStatus, am_SourceClass_L& listSourceClasses, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListSourceClassesAsync(GetListSourceClassesAsyncCallback callback) = 0; + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListSinkClasses(CommonAPI::CallStatus& callStatus, am_SinkClass_L& listSinkClasses, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListSinkClassesAsync(GetListSinkClassesAsyncCallback callback) = 0; + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + virtual void getListSystemProperties(CommonAPI::CallStatus& callStatus, am_SystemProperty_L& listSystemProperties, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListSystemPropertiesAsync(GetListSystemPropertiesAsyncCallback callback) = 0; + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ + virtual void getTimingInformation(const am_mainConnectionID_t& mainConnectionID, CommonAPI::CallStatus& callStatus, am_timeSync_t& delay, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getTimingInformationAsync(const am_mainConnectionID_t& mainConnectionID, GetTimingInformationAsyncCallback callback) = 0; + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ + virtual void getListMainSinkNotificationConfigurations(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainSinkNotificationConfigurationsAsync(const am_sinkID_t& sinkID, GetListMainSinkNotificationConfigurationsAsyncCallback callback) = 0; + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ + virtual void getListMainSourceNotificationConfigurations(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> getListMainSourceNotificationConfigurationsAsync(const am_sourceID_t& sourceID, GetListMainSourceNotificationConfigurationsAsyncCallback callback) = 0; + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ + virtual void setMainSinkNotificationConfiguration(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setMainSinkNotificationConfigurationAsync(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSinkNotificationConfigurationAsyncCallback callback) = 0; + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ + virtual void setMainSourceNotificationConfiguration(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, CommonAPI::CallStatus& callStatus, am_Error_e& error) = 0; + virtual std::future<CommonAPI::CallStatus> setMainSourceNotificationConfigurationAsync(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration, SetMainSourceNotificationConfigurationAsyncCallback callback) = 0; +}; + +} // namespace am +} // namespace genivi +} // namespace org + +#endif // ORG_GENIVI_AM_Command_Control_PROXY_BASE_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h new file mode 100644 index 0000000..4e15ce0 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStub.h @@ -0,0 +1,492 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_STUB_H_ +#define ORG_GENIVI_AM_Command_Control_STUB_H_ + + + +#include <org/genivi/am.h> + +#include "CommandControl.h" + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/InputStream.h> +#include <CommonAPI/OutputStream.h> +#include <CommonAPI/SerializableStruct.h> +#include <cstdint> +#include <string> +#include <unordered_set> +#include <vector> + +#include <CommonAPI/Stub.h> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace org { +namespace genivi { +namespace am { + +/** + * Receives messages from remote and handles all dispatching of deserialized calls + * to a stub for the service CommandControl. Also provides means to send broadcasts + * and attribute-changed-notifications of observable attributes as defined by this service. + * An application developer should not need to bother with this class. + */ +class CommandControlStubAdapter: virtual public CommonAPI::StubAdapter, public CommandControl { + public: + + /** + * Sends a broadcast event for newMainConnection. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) = 0; + /** + * Sends a broadcast event for removedMainConnection. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) = 0; + /** + * Sends a broadcast event for newSink. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireNewSinkEvent(const am_SinkType_s& sink) = 0; + /** + * Sends a broadcast event for removedSink. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireRemovedSinkEvent(const am_sinkID_t& sinkID) = 0; + /** + * Sends a broadcast event for newSource. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireNewSourceEvent(const am_SourceType_s& source) = 0; + /** + * Sends a broadcast event for removedSource. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireRemovedSourceEvent(const am_sourceID_t& source) = 0; + /** + * Sends a broadcast event for numberOfSinkClassesChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireNumberOfSinkClassesChangedEvent() = 0; + /** + * Sends a broadcast event for numberOfSourceClassesChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireNumberOfSourceClassesChangedEvent() = 0; + /** + * Sends a broadcast event for mainConnectionStateChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) = 0; + /** + * Sends a broadcast event for mainSinkSoundPropertyChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) = 0; + /** + * Sends a broadcast event for mainSourceSoundPropertyChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) = 0; + /** + * Sends a broadcast event for sinkAvailabilityChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) = 0; + /** + * Sends a broadcast event for sourceAvailabilityChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) = 0; + /** + * Sends a broadcast event for volumeChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) = 0; + /** + * Sends a broadcast event for sinkMuteStateChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) = 0; + /** + * Sends a broadcast event for systemPropertyChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) = 0; + /** + * Sends a broadcast event for timingInformationChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) = 0; + /** + * Sends a broadcast event for sinkUpdated. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0; + /** + * Sends a broadcast event for sourceUpdated. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0; + /** + * Sends a broadcast event for sinkNotification. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) = 0; + /** + * Sends a broadcast event for sourceNotification. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) = 0; + /** + * Sends a broadcast event for mainSinkNotificationConfigurationChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0; + /** + * Sends a broadcast event for mainSourceNotificationConfigurationChanged. Should not be called directly. + * Instead, the "fire<broadcastName>Event" methods of the stub should be used. + */ + virtual void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0; + + + virtual void deactivateManagedInstances() = 0; +protected: + /** + * Defines properties for storing the ClientIds of clients / proxies that have + * subscribed to the selective broadcasts + */ +}; + + +/** + * Defines the necessary callbacks to handle remote set events related to the attributes + * defined in the IDL description for CommandControl. + * For each attribute two callbacks are defined: + * - a verification callback that allows to verify the requested value and to prevent setting + * e.g. an invalid value ("onRemoteSet<AttributeName>"). + * - an action callback to do local work after the attribute value has been changed + * ("onRemote<AttributeName>Changed"). + * + * This class and the one below are the ones an application developer needs to have + * a look at if he wants to implement a service. + */ +class CommandControlStubRemoteEvent { + public: + virtual ~CommandControlStubRemoteEvent() { } + +}; + + +/** + * Defines the interface that must be implemented by any class that should provide + * the service CommandControl to remote clients. + * This class and the one above are the ones an application developer needs to have + * a look at if he wants to implement a service. + */ +class CommandControlStub: public virtual CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent> { +public: + virtual ~CommandControlStub() { } + virtual const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) = 0; + + + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ + /// This is the method that will be called on remote calls on the method connect. + virtual void connect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) = 0; + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ + /// This is the method that will be called on remote calls on the method disconnect. + virtual void disconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_Error_e& error) = 0; + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ + /// This is the method that will be called on remote calls on the method setVolume. + virtual void setVolume(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error) = 0; + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ + /// This is the method that will be called on remote calls on the method volumeStep. + virtual void volumeStep(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, int16_t volStep, am_Error_e& error) = 0; + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ + /// This is the method that will be called on remote calls on the method setSinkMuteState. + virtual void setSinkMuteState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error) = 0; + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + /// This is the method that will be called on remote calls on the method setMainSinkSoundProperty. + virtual void setMainSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error) = 0; + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + /// This is the method that will be called on remote calls on the method setMainSourceSoundProperty. + virtual void setMainSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error) = 0; + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ + /// This is the method that will be called on remote calls on the method setSystemProperty. + virtual void setSystemProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_s property, am_Error_e& error) = 0; + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method getListMainConnections. + virtual void getListMainConnections(const std::shared_ptr<CommonAPI::ClientId> clientId, am_MainConnection_L& listConnections, am_Error_e& error) = 0; + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + /// This is the method that will be called on remote calls on the method getListMainSinks. + virtual void getListMainSinks(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkType_L& listMainSinks, am_Error_e& error) = 0; + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + /// This is the method that will be called on remote calls on the method getListMainSources. + virtual void getListMainSources(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceType_L& listMainSources, am_Error_e& error) = 0; + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method getListMainSinkSoundProperties. + virtual void getListMainSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) = 0; + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method getListMainSourceSoundProperties. + virtual void getListMainSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) = 0; + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method getListSourceClasses. + virtual void getListSourceClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceClass_L& listSourceClasses, am_Error_e& error) = 0; + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method getListSinkClasses. + virtual void getListSinkClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkClass_L& listSinkClasses, am_Error_e& error) = 0; + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method getListSystemProperties. + virtual void getListSystemProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_L& listSystemProperties, am_Error_e& error) = 0; + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ + /// This is the method that will be called on remote calls on the method getTimingInformation. + virtual void getTimingInformation(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error) = 0; + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ + /// This is the method that will be called on remote calls on the method getListMainSinkNotificationConfigurations. + virtual void getListMainSinkNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0; + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ + /// This is the method that will be called on remote calls on the method getListMainSourceNotificationConfigurations. + virtual void getListMainSourceNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) = 0; + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method setMainSinkNotificationConfiguration. + virtual void setMainSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) = 0; + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ + /// This is the method that will be called on remote calls on the method setMainSourceNotificationConfiguration. + virtual void setMainSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) = 0; + /** + * Callback that is called when the number of connections change + */ + /// Sends a broadcast event for newMainConnection. + virtual void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) = 0; + /** + * Callback that is called when the number of connections change + */ + /// Sends a broadcast event for removedMainConnection. + virtual void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) = 0; + /** + * Callback that is called when the number of sinks change + */ + /// Sends a broadcast event for newSink. + virtual void fireNewSinkEvent(const am_SinkType_s& sink) = 0; + /** + * Callback that is called when the number of sinks change + */ + /// Sends a broadcast event for removedSink. + virtual void fireRemovedSinkEvent(const am_sinkID_t& sinkID) = 0; + /** + * Callback that is called when the number of sources change + */ + /// Sends a broadcast event for newSource. + virtual void fireNewSourceEvent(const am_SourceType_s& source) = 0; + /** + * Callback that is called when the number of sources change + */ + /// Sends a broadcast event for removedSource. + virtual void fireRemovedSourceEvent(const am_sourceID_t& source) = 0; + /** + * this callback is fired if the number of sink classes changed + */ + /// Sends a broadcast event for numberOfSinkClassesChanged. + virtual void fireNumberOfSinkClassesChangedEvent() = 0; + /** + * this callback is fired if the number of source classes changed + */ + /// Sends a broadcast event for numberOfSourceClassesChanged. + virtual void fireNumberOfSourceClassesChangedEvent() = 0; + /** + * This callback is called when the ConnectionState of a connection changed. + */ + /// Sends a broadcast event for mainConnectionStateChanged. + virtual void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) = 0; + /** + * this callback indicates that a sinkSoundProperty has changed. + */ + /// Sends a broadcast event for mainSinkSoundPropertyChanged. + virtual void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) = 0; + /** + * this callback indicates that a sourceSoundProperty has changed. + */ + /// Sends a broadcast event for mainSourceSoundPropertyChanged. + virtual void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) = 0; + /** + * this callback is called when the availability of a sink has changed + */ + /// Sends a broadcast event for sinkAvailabilityChanged. + virtual void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) = 0; + /** + * this callback is called when the availability of source has changed. + */ + /// Sends a broadcast event for sourceAvailabilityChanged. + virtual void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) = 0; + /** + * this callback indicates a volume change on the indicated sink + */ + /// Sends a broadcast event for volumeChanged. + virtual void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) = 0; + /** + * this callback indicates a mute state change on a sink. + */ + /// Sends a broadcast event for sinkMuteStateChanged. + virtual void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) = 0; + /** + * is fired if a systemProperty changed + */ + /// Sends a broadcast event for systemPropertyChanged. + virtual void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) = 0; + /** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ + /// Sends a broadcast event for timingInformationChanged. + virtual void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) = 0; + /** + * This callback is called when a sink is updated. + */ + /// Sends a broadcast event for sinkUpdated. + virtual void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0; + /** + * This callback is called when a source is updated. + */ + /// Sends a broadcast event for sourceUpdated. + virtual void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) = 0; + /** + * This callback is called when a notificated value of a sink changes. + */ + /// Sends a broadcast event for sinkNotification. + virtual void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) = 0; + /** + * This callback is called when a notifcated value of a source changes. + */ + /// Sends a broadcast event for sourceNotification. + virtual void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) = 0; + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + /// Sends a broadcast event for mainSinkNotificationConfigurationChanged. + virtual void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0; + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + /// Sends a broadcast event for mainSourceNotificationConfigurationChanged. + virtual void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) = 0; + + using CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::initStubAdapter; + typedef CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::StubAdapterType StubAdapterType; + typedef CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::RemoteEventHandlerType RemoteEventHandlerType; + typedef CommandControlStubRemoteEvent RemoteEventType; + typedef CommandControl StubInterface; +}; + +} // namespace am +} // namespace genivi +} // namespace org + +#endif // ORG_GENIVI_AM_Command_Control_STUB_H_ diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp new file mode 100644 index 0000000..cca1a5e --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.cpp @@ -0,0 +1,456 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +#include <org/genivi/am/CommandControlStubDefault.h> + +namespace org { +namespace genivi { +namespace am { + +CommandControlStubDefault::CommandControlStubDefault(): + remoteEventHandler_(this), + interfaceVersion_(CommandControl::getInterfaceVersion()) { +} + +const CommonAPI::Version& CommandControlStubDefault::getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) { + return interfaceVersion_; +} + +CommandControlStubRemoteEvent* CommandControlStubDefault::initStubAdapter(const std::shared_ptr<CommandControlStubAdapter>& stubAdapter) { + CommonAPI::Stub<CommandControlStubAdapter, CommandControlStubRemoteEvent>::stubAdapter_ = stubAdapter; + return &remoteEventHandler_; +} + + +/** + * connects a source to sink +(at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ +void CommandControlStubDefault::connect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) { + // Call old style methods in default + connect(sourceID, sinkID, mainConnectionID, error); +} +void CommandControlStubDefault::connect(am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error) { + // No operation in default +} + +/** + * disconnects a mainConnection +(at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ +void CommandControlStubDefault::disconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_Error_e& error) { + // Call old style methods in default + disconnect(mainConnectionID, error); +} +void CommandControlStubDefault::disconnect(am_mainConnectionID_t mainConnectionID, am_Error_e& error) { + // No operation in default +} + +/** + * sets the volume for a sink +(at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ +void CommandControlStubDefault::setVolume(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error) { + // Call old style methods in default + setVolume(sinkID, volume, error); +} +void CommandControlStubDefault::setVolume(am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error) { + // No operation in default +} + +/** + * This function is used to increment or decrement the current volume for a + * sink. +(at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ +void CommandControlStubDefault::volumeStep(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, int16_t volStep, am_Error_e& error) { + // Call old style methods in default + volumeStep(sinkID, volStep, error); +} +void CommandControlStubDefault::volumeStep(am_sinkID_t sinkID, int16_t volStep, am_Error_e& error) { + // No operation in default +} + +/** + * sets the mute state of a sink +(at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ +void CommandControlStubDefault::setSinkMuteState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error) { + // Call old style methods in default + setSinkMuteState(sinkID, muteState, error); +} +void CommandControlStubDefault::setSinkMuteState(am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error) { + // No operation in default +} + +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +void CommandControlStubDefault::setMainSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error) { + // Call old style methods in default + setMainSinkSoundProperty(sinkID, soundProperty, error); +} +void CommandControlStubDefault::setMainSinkSoundProperty(am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error) { + // No operation in default +} + +/** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product +(at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ +void CommandControlStubDefault::setMainSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error) { + // Call old style methods in default + setMainSourceSoundProperty(sourceID, soundProperty, error); +} +void CommandControlStubDefault::setMainSourceSoundProperty(am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error) { + // No operation in default +} + +/** + * is used to set a specific system property. +(at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ +void CommandControlStubDefault::setSystemProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_s property, am_Error_e& error) { + // Call old style methods in default + setSystemProperty(property, error); +} +void CommandControlStubDefault::setSystemProperty(am_SystemProperty_s property, am_Error_e& error) { + // No operation in default +} + +/** + * returns the actual list of MainConnections +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::getListMainConnections(const std::shared_ptr<CommonAPI::ClientId> clientId, am_MainConnection_L& listConnections, am_Error_e& error) { + // Call old style methods in default + getListMainConnections(listConnections, error); +} +void CommandControlStubDefault::getListMainConnections(am_MainConnection_L& listConnections, am_Error_e& error) { + // No operation in default +} + +/** + * returns the actual list of Sinks +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +void CommandControlStubDefault::getListMainSinks(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkType_L& listMainSinks, am_Error_e& error) { + // Call old style methods in default + getListMainSinks(listMainSinks, error); +} +void CommandControlStubDefault::getListMainSinks(am_SinkType_L& listMainSinks, am_Error_e& error) { + // No operation in default +} + +/** + * returns the actual list of Sources +(at)return E_OK on success, E_DATABASE_ERROR + * on error + */ +void CommandControlStubDefault::getListMainSources(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceType_L& listMainSources, am_Error_e& error) { + // Call old style methods in default + getListMainSources(listMainSources, error); +} +void CommandControlStubDefault::getListMainSources(am_SourceType_L& listMainSources, am_Error_e& error) { + // No operation in default +} + +/** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair +(at)return E_OK on + * success, E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::getListMainSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) { + // Call old style methods in default + getListMainSinkSoundProperties(sinkID, listSoundProperties, error); +} +void CommandControlStubDefault::getListMainSinkSoundProperties(am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error) { + // No operation in default +} + +/** + * This is used to retrieve all source sound properties related to a + * source. +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::getListMainSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) { + // Call old style methods in default + getListMainSourceSoundProperties(sourceID, listSourceProperties, error); +} +void CommandControlStubDefault::getListMainSourceSoundProperties(am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error) { + // No operation in default +} + +/** + * This is used to retrieve SourceClass Information of all source classes + * +(at)return E_OK on success, E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::getListSourceClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceClass_L& listSourceClasses, am_Error_e& error) { + // Call old style methods in default + getListSourceClasses(listSourceClasses, error); +} +void CommandControlStubDefault::getListSourceClasses(am_SourceClass_L& listSourceClasses, am_Error_e& error) { + // No operation in default +} + +/** + * This is used to retrieve SinkClass Information of all sink classes +(at)return + * E_OK on success, E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::getListSinkClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkClass_L& listSinkClasses, am_Error_e& error) { + // Call old style methods in default + getListSinkClasses(listSinkClasses, error); +} +void CommandControlStubDefault::getListSinkClasses(am_SinkClass_L& listSinkClasses, am_Error_e& error) { + // No operation in default +} + +/** + * Retrieves a complete list of all systemProperties. +(at)return E_OK on success, + * E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::getListSystemProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_L& listSystemProperties, am_Error_e& error) { + // Call old style methods in default + getListSystemProperties(listSystemProperties, error); +} +void CommandControlStubDefault::getListSystemProperties(am_SystemProperty_L& listSystemProperties, am_Error_e& error) { + // No operation in default +} + +/** + * returns the delay in ms that the audiopath for the given mainConnection + * has +(at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ +void CommandControlStubDefault::getTimingInformation(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error) { + // Call old style methods in default + getTimingInformation(mainConnectionID, delay, error); +} +void CommandControlStubDefault::getTimingInformation(am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error) { + // No operation in default +} + +/** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ +void CommandControlStubDefault::getListMainSinkNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + // Call old style methods in default + getListMainSinkNotificationConfigurations(sinkID, listMainNotificationConfigurations, error); +} +void CommandControlStubDefault::getListMainSinkNotificationConfigurations(am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + // No operation in default +} + +/** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ +void CommandControlStubDefault::getListMainSourceNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + // Call old style methods in default + getListMainSourceNotificationConfigurations(sourceID, listMainNotificationConfigurations, error); +} +void CommandControlStubDefault::getListMainSourceNotificationConfigurations(am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error) { + // No operation in default +} + +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::setMainSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) { + // Call old style methods in default + setMainSinkNotificationConfiguration(sinkID, mainNotificationConfiguration, error); +} +void CommandControlStubDefault::setMainSinkNotificationConfiguration(am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) { + // No operation in default +} + +/** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. +(at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ +void CommandControlStubDefault::setMainSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) { + // Call old style methods in default + setMainSourceNotificationConfiguration(sourceID, mainNotificationConfiguration, error); +} +void CommandControlStubDefault::setMainSourceNotificationConfiguration(am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error) { + // No operation in default +} + + +/** + * Callback that is called when the number of connections change + */ +void CommandControlStubDefault::fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection) { + stubAdapter_->fireNewMainConnectionEvent(mainConnection); +} +/** + * Callback that is called when the number of connections change + */ +void CommandControlStubDefault::fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection) { + stubAdapter_->fireRemovedMainConnectionEvent(mainConnection); +} +/** + * Callback that is called when the number of sinks change + */ +void CommandControlStubDefault::fireNewSinkEvent(const am_SinkType_s& sink) { + stubAdapter_->fireNewSinkEvent(sink); +} +/** + * Callback that is called when the number of sinks change + */ +void CommandControlStubDefault::fireRemovedSinkEvent(const am_sinkID_t& sinkID) { + stubAdapter_->fireRemovedSinkEvent(sinkID); +} +/** + * Callback that is called when the number of sources change + */ +void CommandControlStubDefault::fireNewSourceEvent(const am_SourceType_s& source) { + stubAdapter_->fireNewSourceEvent(source); +} +/** + * Callback that is called when the number of sources change + */ +void CommandControlStubDefault::fireRemovedSourceEvent(const am_sourceID_t& source) { + stubAdapter_->fireRemovedSourceEvent(source); +} +/** + * this callback is fired if the number of sink classes changed + */ +void CommandControlStubDefault::fireNumberOfSinkClassesChangedEvent() { + stubAdapter_->fireNumberOfSinkClassesChangedEvent(); +} +/** + * this callback is fired if the number of source classes changed + */ +void CommandControlStubDefault::fireNumberOfSourceClassesChangedEvent() { + stubAdapter_->fireNumberOfSourceClassesChangedEvent(); +} +/** + * This callback is called when the ConnectionState of a connection changed. + */ +void CommandControlStubDefault::fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState) { + stubAdapter_->fireMainConnectionStateChangedEvent(connectionID, connectionState); +} +/** + * this callback indicates that a sinkSoundProperty has changed. + */ +void CommandControlStubDefault::fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty) { + stubAdapter_->fireMainSinkSoundPropertyChangedEvent(sinkID, soundProperty); +} +/** + * this callback indicates that a sourceSoundProperty has changed. + */ +void CommandControlStubDefault::fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty) { + stubAdapter_->fireMainSourceSoundPropertyChangedEvent(sourceID, soundProperty); +} +/** + * this callback is called when the availability of a sink has changed + */ +void CommandControlStubDefault::fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability) { + stubAdapter_->fireSinkAvailabilityChangedEvent(sinkID, availability); +} +/** + * this callback is called when the availability of source has changed. + */ +void CommandControlStubDefault::fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability) { + stubAdapter_->fireSourceAvailabilityChangedEvent(sourceID, availability); +} +/** + * this callback indicates a volume change on the indicated sink + */ +void CommandControlStubDefault::fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume) { + stubAdapter_->fireVolumeChangedEvent(sinkID, volume); +} +/** + * this callback indicates a mute state change on a sink. + */ +void CommandControlStubDefault::fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState) { + stubAdapter_->fireSinkMuteStateChangedEvent(sinkID, muteState); +} +/** + * is fired if a systemProperty changed + */ +void CommandControlStubDefault::fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty) { + stubAdapter_->fireSystemPropertyChangedEvent(systemProperty); +} +/** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ +void CommandControlStubDefault::fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time) { + stubAdapter_->fireTimingInformationChangedEvent(mainConnectionID, time); +} +/** + * This callback is called when a sink is updated. + */ +void CommandControlStubDefault::fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties) { + stubAdapter_->fireSinkUpdatedEvent(sinkID, sinkClassID, listMainSoundProperties); +} +/** + * This callback is called when a source is updated. + */ +void CommandControlStubDefault::fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties) { + stubAdapter_->fireSourceUpdatedEvent(sourceID, sourceClassID, listMainSoundProperties); +} +/** + * This callback is called when a notificated value of a sink changes. + */ +void CommandControlStubDefault::fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification) { + stubAdapter_->fireSinkNotificationEvent(sinkID, notification); +} +/** + * This callback is called when a notifcated value of a source changes. + */ +void CommandControlStubDefault::fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification) { + stubAdapter_->fireSourceNotificationEvent(sourceID, notification); +} +/** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ +void CommandControlStubDefault::fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration) { + stubAdapter_->fireMainSinkNotificationConfigurationChangedEvent(sinkID, mainNotificationConfiguration); +} +/** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ +void CommandControlStubDefault::fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration) { + stubAdapter_->fireMainSourceNotificationConfigurationChangedEvent(sourceID, mainNotificationConfiguration); +} + + +CommandControlStubDefault::RemoteEventHandler::RemoteEventHandler(CommandControlStubDefault* defaultStub): + defaultStub_(defaultStub) { +} + +} // namespace am +} // namespace genivi +} // namespace org diff --git a/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h new file mode 100644 index 0000000..a6d46f8 --- /dev/null +++ b/PluginCommandInterfaceCAPI/src-gen/org/genivi/am/CommandControlStubDefault.h @@ -0,0 +1,336 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 2.1.6.v20150127. +* Used org.franca.core 0.8.10.201309262002. +* +* +*/ +/** + * The interface towards the Controlling Instance (e.g HMI). It handles the + * communication towards the HMI and other system components who need to interact + * with the audiomanagement. +There are two rules that have to be kept in mind + * when implementing against this interface: + * @author Christian Mueller + */ +#ifndef ORG_GENIVI_AM_Command_Control_STUB_DEFAULT_H_ +#define ORG_GENIVI_AM_Command_Control_STUB_DEFAULT_H_ + + +#include <org/genivi/am/CommandControlStub.h> +#include <sstream> + +namespace org { +namespace genivi { +namespace am { + +/** + * Provides a default implementation for CommandControlStubRemoteEvent and + * CommandControlStub. Method callbacks have an empty implementation, + * remote set calls on attributes will always change the value of the attribute + * to the one received. + * + * Override this stub if you only want to provide a subset of the functionality + * that would be defined for this service, and/or if you do not need any non-default + * behaviour. + */ +class CommandControlStubDefault : public virtual CommandControlStub { +public: + CommandControlStubDefault(); + + CommandControlStubRemoteEvent* initStubAdapter(const std::shared_ptr<CommandControlStubAdapter>& stubAdapter); + + const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId); + + + /** + * connects a source to sink + (at)return E_OK on success, E_NOT_POSSIBLE on + * failure, E_ALREADY_EXISTS if the connection does already exists + */ + virtual void connect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error); + virtual void connect(am_sourceID_t sourceID, am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID, am_Error_e& error); + + /** + * disconnects a mainConnection + (at)return E_OK on successes, E_NON_EXISTENT if + * the connection does not exist, E_NOT_POSSIBLE on error. + */ + virtual void disconnect(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_Error_e& error); + virtual void disconnect(am_mainConnectionID_t mainConnectionID, am_Error_e& error); + + /** + * sets the volume for a sink + (at)return E_OK on success, E_UNKOWN on error, + * E_OUT_OF_RANGE in case the value is out of range + */ + virtual void setVolume(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error); + virtual void setVolume(am_sinkID_t sinkID, am_mainVolume_t volume, am_Error_e& error); + + /** + * This function is used to increment or decrement the current volume for a + * sink. + (at)return E_OK on success, E_UNKNOWN on error and E_OUT_OF_RANGE if the + * value is not in the given volume range. + */ + virtual void volumeStep(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, int16_t volStep, am_Error_e& error); + virtual void volumeStep(am_sinkID_t sinkID, int16_t volStep, am_Error_e& error); + + /** + * sets the mute state of a sink + (at)return E_OK on success, E_UNKNOWN on error. + * If the mute state is already the desired one, the Daemon will return E_OK. + */ + virtual void setSinkMuteState(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error); + virtual void setSinkMuteState(am_sinkID_t sinkID, am_MuteState_e muteState, am_Error_e& error); + + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + virtual void setMainSinkSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error); + virtual void setMainSinkSoundProperty(am_sinkID_t sinkID, am_MainSoundProperty_s soundProperty, am_Error_e& error); + + /** + * This method is used to set sound properties, e.g. Equalizer Values. Since the + * capabilities of the system can differ, the exact key value pairs can be + * extended in each product + (at)return E_OK on success, E_OUT_OF_RANGE if value + * exceeds range, E_UNKNOWN in case of an error + */ + virtual void setMainSourceSoundProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error); + virtual void setMainSourceSoundProperty(am_sourceID_t sourceID, am_MainSoundProperty_s soundProperty, am_Error_e& error); + + /** + * is used to set a specific system property. + (at)return E_OK on success, + * E_OUT_OF_RANGE if value exceeds range, E_UNKNOWN in case of an error + */ + virtual void setSystemProperty(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_s property, am_Error_e& error); + virtual void setSystemProperty(am_SystemProperty_s property, am_Error_e& error); + + /** + * returns the actual list of MainConnections + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + virtual void getListMainConnections(const std::shared_ptr<CommonAPI::ClientId> clientId, am_MainConnection_L& listConnections, am_Error_e& error); + virtual void getListMainConnections(am_MainConnection_L& listConnections, am_Error_e& error); + + /** + * returns the actual list of Sinks + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + virtual void getListMainSinks(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkType_L& listMainSinks, am_Error_e& error); + virtual void getListMainSinks(am_SinkType_L& listMainSinks, am_Error_e& error); + + /** + * returns the actual list of Sources + (at)return E_OK on success, E_DATABASE_ERROR + * on error + */ + virtual void getListMainSources(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceType_L& listMainSources, am_Error_e& error); + virtual void getListMainSources(am_SourceType_L& listMainSources, am_Error_e& error); + + /** + * This is used to retrieve all source sound properties related to a source. + * Returns a vector of the sound properties and values as pair + (at)return E_OK on + * success, E_DATABASE_ERROR on error + */ + virtual void getListMainSinkSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error); + virtual void getListMainSinkSoundProperties(am_sinkID_t sinkID, am_MainSoundProperty_L& listSoundProperties, am_Error_e& error); + + /** + * This is used to retrieve all source sound properties related to a + * source. + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListMainSourceSoundProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error); + virtual void getListMainSourceSoundProperties(am_sourceID_t sourceID, am_MainSoundProperty_L& listSourceProperties, am_Error_e& error); + + /** + * This is used to retrieve SourceClass Information of all source classes + * + (at)return E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListSourceClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SourceClass_L& listSourceClasses, am_Error_e& error); + virtual void getListSourceClasses(am_SourceClass_L& listSourceClasses, am_Error_e& error); + + /** + * This is used to retrieve SinkClass Information of all sink classes + (at)return + * E_OK on success, E_DATABASE_ERROR on error + */ + virtual void getListSinkClasses(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SinkClass_L& listSinkClasses, am_Error_e& error); + virtual void getListSinkClasses(am_SinkClass_L& listSinkClasses, am_Error_e& error); + + /** + * Retrieves a complete list of all systemProperties. + (at)return E_OK on success, + * E_DATABASE_ERROR on error + */ + virtual void getListSystemProperties(const std::shared_ptr<CommonAPI::ClientId> clientId, am_SystemProperty_L& listSystemProperties, am_Error_e& error); + virtual void getListSystemProperties(am_SystemProperty_L& listSystemProperties, am_Error_e& error); + + /** + * returns the delay in ms that the audiopath for the given mainConnection + * has + (at)return E_OK on success, E_NOT_POSSIBLE if timing information is not + * yet retrieved, E_DATABASE_ERROR on read error on the database + */ + virtual void getTimingInformation(const std::shared_ptr<CommonAPI::ClientId> clientId, am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error); + virtual void getTimingInformation(am_mainConnectionID_t mainConnectionID, am_timeSync_t& delay, am_Error_e& error); + + /** + * Retrieves the list of MainNotifications for a sink. Does not return the + * possible ones. + */ + virtual void getListMainSinkNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + virtual void getListMainSinkNotificationConfigurations(am_sinkID_t sinkID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + + /** + * Retrieves the list of MainNotifications for a source. Does not return the + * possible ones. + */ + virtual void getListMainSourceNotificationConfigurations(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + virtual void getListMainSourceNotificationConfigurations(am_sourceID_t sourceID, am_NotificationConfiguration_L& listMainNotificationConfigurations, am_Error_e& error); + + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sinkID does not exists, E_DATABASE_ERROR on error + */ + virtual void setMainSinkNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error); + virtual void setMainSinkNotificationConfiguration(am_sinkID_t sinkID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error); + + /** + * sets a MainNotificationConfiuration. This can be used to turn on an off + * notifications an to change the mode of the configuration. + (at)return E_OK on + * success, E_NON_EXISTENT if sourceID does not exists, E_DATABASE_ERROR on error + */ + virtual void setMainSourceNotificationConfiguration(const std::shared_ptr<CommonAPI::ClientId> clientId, am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error); + virtual void setMainSourceNotificationConfiguration(am_sourceID_t sourceID, am_NotificationConfiguration_s mainNotificationConfiguration, am_Error_e& error); + + + /** + * Callback that is called when the number of connections change + */ + virtual void fireNewMainConnectionEvent(const am_MainConnectionType_s& mainConnection); + /** + * Callback that is called when the number of connections change + */ + virtual void fireRemovedMainConnectionEvent(const am_mainConnectionID_t& mainConnection); + /** + * Callback that is called when the number of sinks change + */ + virtual void fireNewSinkEvent(const am_SinkType_s& sink); + /** + * Callback that is called when the number of sinks change + */ + virtual void fireRemovedSinkEvent(const am_sinkID_t& sinkID); + /** + * Callback that is called when the number of sources change + */ + virtual void fireNewSourceEvent(const am_SourceType_s& source); + /** + * Callback that is called when the number of sources change + */ + virtual void fireRemovedSourceEvent(const am_sourceID_t& source); + /** + * this callback is fired if the number of sink classes changed + */ + virtual void fireNumberOfSinkClassesChangedEvent(); + /** + * this callback is fired if the number of source classes changed + */ + virtual void fireNumberOfSourceClassesChangedEvent(); + /** + * This callback is called when the ConnectionState of a connection changed. + */ + virtual void fireMainConnectionStateChangedEvent(const am_mainConnectionID_t& connectionID, const am_ConnectionState_e& connectionState); + /** + * this callback indicates that a sinkSoundProperty has changed. + */ + virtual void fireMainSinkSoundPropertyChangedEvent(const am_sinkID_t& sinkID, const am_MainSoundProperty_s& soundProperty); + /** + * this callback indicates that a sourceSoundProperty has changed. + */ + virtual void fireMainSourceSoundPropertyChangedEvent(const am_sourceID_t& sourceID, const am_MainSoundProperty_s& soundProperty); + /** + * this callback is called when the availability of a sink has changed + */ + virtual void fireSinkAvailabilityChangedEvent(const am_sinkID_t& sinkID, const am_Availability_s& availability); + /** + * this callback is called when the availability of source has changed. + */ + virtual void fireSourceAvailabilityChangedEvent(const am_sourceID_t& sourceID, const am_Availability_s& availability); + /** + * this callback indicates a volume change on the indicated sink + */ + virtual void fireVolumeChangedEvent(const am_sinkID_t& sinkID, const am_mainVolume_t& volume); + /** + * this callback indicates a mute state change on a sink. + */ + virtual void fireSinkMuteStateChangedEvent(const am_sinkID_t& sinkID, const am_MuteState_e& muteState); + /** + * is fired if a systemProperty changed + */ + virtual void fireSystemPropertyChangedEvent(const am_SystemProperty_s& systemProperty); + /** + * This callback is fired if the timinginformation for a mainConnectionID changed + */ + virtual void fireTimingInformationChangedEvent(const am_mainConnectionID_t& mainConnectionID, const am_timeSync_t& time); + /** + * This callback is called when a sink is updated. + */ + virtual void fireSinkUpdatedEvent(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_MainSoundProperty_L& listMainSoundProperties); + /** + * This callback is called when a source is updated. + */ + virtual void fireSourceUpdatedEvent(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_MainSoundProperty_L& listMainSoundProperties); + /** + * This callback is called when a notificated value of a sink changes. + */ + virtual void fireSinkNotificationEvent(const am_sinkID_t& sinkID, const am_NotificationPayload_s& notification); + /** + * This callback is called when a notifcated value of a source changes. + */ + virtual void fireSourceNotificationEvent(const am_sourceID_t& sourceID, const am_NotificationPayload_s& notification); + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + virtual void fireMainSinkNotificationConfigurationChangedEvent(const am_sinkID_t& sinkID, const am_NotificationConfiguration_s& mainNotificationConfiguration); + /** + * This callback is triggered when a mainNotificationConfiguration is changed. + */ + virtual void fireMainSourceNotificationConfigurationChangedEvent(const am_sourceID_t& sourceID, const am_NotificationConfiguration_s& mainNotificationConfiguration); + + +protected: + class RemoteEventHandler: public virtual CommandControlStubRemoteEvent { + public: + RemoteEventHandler(CommandControlStubDefault* defaultStub); + + + private: + CommandControlStubDefault* defaultStub_; + }; +private: + CommandControlStubDefault::RemoteEventHandler remoteEventHandler_; + + + CommonAPI::Version interfaceVersion_; +}; + +} // namespace am +} // namespace genivi +} // namespace org + +#endif // ORG_GENIVI_AM_Command_Control_STUB_DEFAULT_H_ |