AudioManagerDaemon/test/CAmCommonFunctions.cpp

   1 /**
   2  * Copyright (C) 2012, BMW AG
   3  *
   4  * This file is part of GENIVI Project AudioManager.
   5  *
   6  * Contributions are licensed to the GENIVI Alliance under one or more
   7  * Contribution License Agreements.
   8  *
   9  * \copyright
  10  * This Source Code Form is subject to the terms of the
  11  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  12  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  13  *
  14  *
  15  * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
  16  *
  17  * For further information see http://www.genivi.org/.
  18  *
  19  */
  20
  21 #include "CAmCommonFunctions.h"
  22 #include "IAmCommandBackdoor.h"
  23 #include "IAmRoutingBackdoor.h"
  24 #include "IAmControlBackdoor.h"
  25 #include <cassert>
  26 #include <sstream>
  27
  28 using namespace am;
  29
  30 IAmCommandBackdoor::IAmCommandBackdoor()
  31 {
  32 }
  33 IAmCommandBackdoor::~IAmCommandBackdoor()
  34 {
  35 }
  36
  37 bool IAmCommandBackdoor::unloadPlugins(CAmCommandSender *CommandSender)
  38 {
  39     assert(CommandSender != NULL);
  40     CommandSender->unloadLibraries();
  41     CommandSender->mListInterfaces.clear();
  42     if (CommandSender->mListInterfaces.empty())
  43         return true;
  44     return false;
  45 }
  46
  47 bool IAmCommandBackdoor::injectInterface(CAmCommandSender *CommandSender, IAmCommandSend *CommandSendInterface)
  48 {
  49     assert(CommandSender != NULL);
  50     assert(CommandSendInterface != NULL);
  51     CommandSender->mListInterfaces.push_back(CommandSendInterface);
  52     return true;
  53 }
  54
  55 IAmRoutingBackdoor::IAmRoutingBackdoor()
  56 {
  57 }
  58 IAmRoutingBackdoor::~IAmRoutingBackdoor()
  59 {
  60 }
  61
  62 bool IAmRoutingBackdoor::unloadPlugins(CAmRoutingSender *RoutingSender)
  63 {
  64     assert(RoutingSender != NULL);
  65     RoutingSender->unloadLibraries();
  66     RoutingSender->mListInterfaces.clear();
  67     if (RoutingSender->mListInterfaces.empty())
  68         return true;
  69     return false;
  70 }
  71
  72 bool IAmRoutingBackdoor::injectInterface(CAmRoutingSender *RoutingSender, IAmRoutingSend *newInterface, const std::string& busname)
  73 {
  74     assert(RoutingSender != NULL);
  75     assert(newInterface != NULL);
  76
  77     CAmRoutingSender::InterfaceNamePairs newInterfacePair;
  78     newInterfacePair.routingInterface = newInterface;
  79     newInterfacePair.busName = busname;
  80     RoutingSender->mListInterfaces.push_back(newInterfacePair);
  81     return true;
  82 }
  83
  84 IAmControlBackdoor::IAmControlBackdoor()
  85 {
  86 }
  87
  88 IAmControlBackdoor::~IAmControlBackdoor()
  89 {
  90 }
  91
  92 bool IAmControlBackdoor::replaceController(CAmControlSender *controlSender, IAmControlSend *newController)
  93 {
  94     controlSender->mController = newController;
  95     return true;
  96 }
  97
  98 //int GetRandomNumber(int nLow, int nHigh) {
  99 //      return (rand() % (nHigh - nLow + 1)) + nLow;
 100 //}
 101
 102 bool equalSoundProperty(const am_SoundProperty_s a, const am_SoundProperty_s b)
 103 {
 104     return (a.type == b.type && a.value == b.value);
 105 }
 106
 107 bool equalMainSoundProperty(const am_MainSoundProperty_s a, const am_MainSoundProperty_s b)
 108 {
 109     return (a.type == b.type && a.value == b.value);
 110 }
 111
 112 bool equalNotificationConfiguration(const am_NotificationConfiguration_s a, const am_NotificationConfiguration_s b)
 113 {
 114     return (a.parameter == b.parameter && a.status == b.status && a.type == b.type);
 115 }
 116
 117 bool equalRoutingElement(const am_RoutingElement_s a, const am_RoutingElement_s b)
 118 {
 119     return (a.connectionFormat == b.connectionFormat && a.domainID == b.domainID && a.sinkID == b.sinkID && a.sourceID == b.sourceID);
 120 }
 121
 122 bool equalClassProperties(const am_ClassProperty_s a, const am_ClassProperty_s b)
 123 {
 124     return (a.classProperty == b.classProperty && a.value == b.value);
 125 }
 126
 127 std::string int2string(int i)
 128 {
 129     std::stringstream out;
 130     out << i;
 131     return out.str();
 132 }
 133
 134 bool CAmCommonFunctions::compareSource(std::vector<am_Source_s>::iterator listIterator, const am_Source_s& sourceData)
 135 {
 136     return (listIterator->available.availability == sourceData.available.availability) && \
 137                 (listIterator->available.availabilityReason == sourceData.available.availabilityReason) &&
 138                 (listIterator->sourceClassID == sourceData.sourceClassID) &&
 139                 (listIterator->domainID == sourceData.domainID) &&
 140                 (listIterator->interruptState == sourceData.interruptState) &&
 141                 (listIterator->visible == sourceData.visible) &&
 142                 (listIterator->name.compare(sourceData.name) == 0) &&
 143                 (listIterator->volume == sourceData.volume) &&
 144                 std::equal(listIterator->listConnectionFormats.begin(), listIterator->listConnectionFormats.end(), sourceData.listConnectionFormats.begin()) &&
 145             std::equal(listIterator->listMainSoundProperties.begin(), listIterator->listMainSoundProperties.end(), sourceData.listMainSoundProperties.begin(), equalMainSoundProperty) &&
 146             std::equal(listIterator->listSoundProperties.begin(), listIterator->listSoundProperties.end(), sourceData.listSoundProperties.begin(), equalSoundProperty);
 147 }
 148
 149 bool CAmCommonFunctions::compareSink(std::vector<am_Sink_s>::iterator listIterator, const am_Sink_s& sinkData)
 150 {
 151     return (listIterator->available.availability == sinkData.available.availability) && (listIterator->available.availabilityReason == sinkData.available.availabilityReason) && (listIterator->sinkClassID == sinkData.sinkClassID) && (listIterator->domainID == sinkData.domainID) && (listIterator->mainVolume == sinkData.mainVolume) && (listIterator->muteState == sinkData.muteState) && (listIterator->visible == sinkData.visible) && (listIterator->name.compare(sinkData.name) == 0) && (listIterator->volume == sinkData.volume) && std::equal(listIterator->listConnectionFormats.begin(), listIterator->listConnectionFormats.end(), sinkData.listConnectionFormats.begin())
 152             && std::equal(listIterator->listMainSoundProperties.begin(), listIterator->listMainSoundProperties.end(), sinkData.listMainSoundProperties.begin(), equalMainSoundProperty) && std::equal(listIterator->listSoundProperties.begin(), listIterator->listSoundProperties.end(), sinkData.listSoundProperties.begin(), equalSoundProperty);
 153 }
 154
 155 bool CAmCommonFunctions::compareGateway(std::vector<am_Gateway_s>::iterator listIterator, const am_Gateway_s& gatewayData)
 156 {
 157     return (listIterator->name.compare(gatewayData.name) == 0) && (listIterator->sinkID == gatewayData.sinkID) && (listIterator->sourceID == gatewayData.sourceID) && (listIterator->controlDomainID == gatewayData.controlDomainID) && (listIterator->domainSinkID == gatewayData.domainSinkID) && (listIterator->domainSourceID == gatewayData.domainSourceID) && std::equal(listIterator->convertionMatrix.begin(), listIterator->convertionMatrix.end(), gatewayData.convertionMatrix.begin()) && std::equal(listIterator->listSourceFormats.begin(), listIterator->listSourceFormats.end(), gatewayData.listSourceFormats.begin()) && std::equal(listIterator->listSinkFormats.begin(), listIterator->listSinkFormats.end(), gatewayData.listSinkFormats.begin());
 158 }
 159
 160 bool CAmCommonFunctions::compareGateway1(const am_Gateway_s gateway1, const am_Gateway_s gatewayData)
 161 {
 162     return (gateway1.name.compare(gatewayData.name) == 0) && (gateway1.sinkID == gatewayData.sinkID) && (gateway1.sourceID == gatewayData.sourceID) && (gateway1.controlDomainID == gatewayData.controlDomainID) && (gateway1.domainSinkID == gatewayData.domainSinkID) && (gateway1.domainSourceID == gatewayData.domainSourceID) && std::equal(gateway1.convertionMatrix.begin(), gateway1.convertionMatrix.end(), gatewayData.convertionMatrix.begin()) && std::equal(gateway1.listSourceFormats.begin(), gateway1.listSourceFormats.end(), gatewayData.listSourceFormats.begin()) && std::equal(gateway1.listSinkFormats.begin(), gateway1.listSinkFormats.end(), gatewayData.listSinkFormats.begin());
 163 }
 164
 165 bool CAmCommonFunctions::compareSinkMainSink(std::vector<am_SinkType_s>::iterator listIterator, const std::vector<am_Sink_s>& sinkList)
 166 {
 167     std::vector<am_Sink_s>::const_iterator sinkListIterator = sinkList.begin();
 168     for (; sinkListIterator < sinkList.end(); ++sinkListIterator)
 169     {
 170         if (listIterator->sinkID == sinkListIterator->sinkID)
 171         {
 172             return (listIterator->name.compare(sinkListIterator->name) == 0) && (listIterator->availability.availability == sinkListIterator->available.availability) && (listIterator->availability.availabilityReason == sinkListIterator->available.availabilityReason) && (listIterator->muteState == sinkListIterator->muteState) && (listIterator->volume == sinkListIterator->mainVolume) && (listIterator->sinkClassID == sinkListIterator->sinkClassID);
 173         }
 174     }
 175     return false;
 176 }
 177
 178 bool CAmCommonFunctions::compareSinkMainSource(std::vector<am_SourceType_s>::iterator listIterator, const std::vector<am_Source_s>& sourceList)
 179 {
 180     std::vector<am_Source_s>::const_iterator sinkListIterator = sourceList.begin();
 181     for (; sinkListIterator < sourceList.end(); ++sinkListIterator)
 182     {
 183         if (listIterator->sourceID == sinkListIterator->sourceID)
 184         {
 185             return (listIterator->name.compare(sinkListIterator->name) == 0) && (listIterator->availability.availability == sinkListIterator->available.availability) && (listIterator->availability.availabilityReason == sinkListIterator->available.availabilityReason) && (listIterator->sourceClassID == sinkListIterator->sourceClassID);
 186         }
 187     }
 188     return false;
 189 }
 190
 191 bool CAmCommonFunctions::compareRoute(am_Route_s a, am_Route_s b)
 192 {
 193     bool retVal = true;
 194     std::vector<am_RoutingElement_s>::iterator itA = a.route.begin(), itB = b.route.begin();
 195     retVal &= a.sourceID == b.sourceID;
 196     retVal &= a.sinkID == b.sinkID;
 197     for (; itA != a.route.end(); ++itA)
 198     {
 199         retVal &= itA->sinkID == itB->sinkID;
 200         retVal &= itA->sourceID == itB->sourceID;
 201         retVal &= itA->connectionFormat == itB->connectionFormat;
 202         retVal &= itA->domainID == itB->domainID;
 203         itB++;
 204     }
 205     return retVal;
 206 }
 207
 208 std::vector<am_ConnectionFormat_e> CAmCommonFunctions::getStandardConnectionFormatList()
 209 {
 210     std::vector<am_ConnectionFormat_e> list;
 211     list.push_back(CF_GENIVI_ANALOG);
 212     list.push_back(CF_GENIVI_STEREO);
 213     return list;
 214 }
 215
 216 std::vector<am_SoundProperty_s> CAmCommonFunctions::getStandardSoundPropertyList()
 217 {
 218     std::vector<am_SoundProperty_s> soundPropertyList;
 219     am_SoundProperty_s soundProperty;
 220     soundProperty.type = SP_EXAMPLE_BASS;
 221     soundProperty.value = 23;
 222     soundPropertyList.push_back(soundProperty);
 223     soundProperty.type = SP_EXAMPLE_MID;
 224     soundProperty.value = 2;
 225     soundPropertyList.push_back(soundProperty);
 226     return soundPropertyList;
 227 }
 228
 229 std::vector<am_MainSoundProperty_s> CAmCommonFunctions::getStandardMainSoundPropertyList()
 230 {
 231     std::vector<am_MainSoundProperty_s> mainSoundPropertyList;
 232     am_MainSoundProperty_s mainSoundProperty;
 233     mainSoundProperty.type = MSP_UNKNOWN;
 234     mainSoundProperty.value = 23;
 235     mainSoundPropertyList.push_back(mainSoundProperty);
 236     mainSoundProperty.type = MSP_UNKNOWN;
 237     mainSoundProperty.value = 3;
 238     mainSoundPropertyList.push_back(mainSoundProperty);
 239     return mainSoundPropertyList;
 240 }
 241
 242 void CAmCommonFunctions::createSink(am_Sink_s& sink) const
 243 {
 244     sink.name = "AnySink";
 245     sink.domainID = 4;
 246     sink.available.availability = A_AVAILABLE;
 247     sink.available.availabilityReason = AR_GENIVI_NEWMEDIA;
 248     sink.sinkClassID = 1;
 249     sink.listConnectionFormats = getStandardConnectionFormatList();
 250     sink.listSoundProperties = getStandardSoundPropertyList();
 251     sink.listMainSoundProperties = getStandardMainSoundPropertyList();
 252     sink.listNotificationConfigurations = getStandardNotificationConfigurationList();
 253     sink.listMainNotificationConfigurations = getStandardNotificationConfigurationList();
 254     sink.mainVolume = 12;
 255     sink.muteState = MS_UNMUTED;
 256     sink.visible = true;
 257     sink.volume = 23;
 258     sink.sinkID = 0;
 259 }
 260
 261 void CAmCommonFunctions::createSource(am_Source_s& source) const
 262 {
 263     source.name = "AnySource";
 264     source.domainID = 4;
 265     source.available.availability = A_AVAILABLE;
 266     source.available.availabilityReason = AR_GENIVI_NEWMEDIA;
 267     source.sourceClassID = 1;
 268     source.listConnectionFormats = getStandardConnectionFormatList();
 269     source.listSoundProperties = getStandardSoundPropertyList();
 270     source.listMainSoundProperties = getStandardMainSoundPropertyList();
 271     source.listMainNotificationConfigurations=getStandardNotificationConfigurationList();
 272     source.listNotificationConfigurations=getStandardNotificationConfigurationList();
 273     source.interruptState = IS_OFF;
 274     source.visible = true;
 275     source.volume = 23;
 276     source.sourceID = 0;
 277     source.sourceState = SS_ON;
 278 }
 279
 280 void CAmCommonFunctions::createDomain(am_Domain_s & domain) const
 281 {
 282
 283     domain.domainID = 0;
 284     domain.name = "AnyDomain";
 285     domain.nodename = "AnyNode";
 286     domain.busname = "AnyBusname";
 287     domain.complete = true;
 288     domain.early = true;
 289     domain.state = DS_CONTROLLED;
 290 }
 291
 292 void CAmCommonFunctions::createGateway(am_Gateway_s & gateway)
 293 {
 294     gateway.name = "AnyGateway";
 295     gateway.sinkID = 1;
 296     gateway.sourceID = 2;
 297     gateway.controlDomainID = 1;
 298     gateway.domainSinkID = 3;
 299     gateway.domainSourceID = 4;
 300     gateway.convertionMatrix = getStandardConvertionMatrix();
 301     gateway.listSourceFormats = getStandardConnectionFormatList();
 302     gateway.listSinkFormats = getStandardConnectionFormatList();
 303     gateway.gatewayID = 0;
 304
 305 }
 306
 307 void CAmCommonFunctions::createConnection(am_Connection_s & connection) const
 308 {
 309     connection.connectionID = 0;
 310     connection.sinkID = 1;
 311     connection.sourceID = 2;
 312     connection.delay = -1;
 313     connection.connectionFormat = CF_GENIVI_ANALOG;
 314 }
 315
 316 std::vector<bool> CAmCommonFunctions::getStandardConvertionMatrix()
 317 {
 318     std::vector<bool> convMatrix;
 319     convMatrix.push_back(true);
 320     convMatrix.push_back(false);
 321     convMatrix.push_back(true);
 322     convMatrix.push_back(false);
 323     convMatrix.push_back(true);
 324     convMatrix.push_back(true);
 325     return convMatrix;
 326 }
 327
 328 std::vector<am_NotificationConfiguration_s> am::CAmCommonFunctions::getStandardNotificationConfigurationList()
 329 {
 330     std::vector<am_NotificationConfiguration_s> listNotificationConfigurations;
 331     am_NotificationConfiguration_s tempNotificationConfiguration;
 332     tempNotificationConfiguration.parameter=12;
 333     tempNotificationConfiguration.status=NS_PERIODIC;
 334     tempNotificationConfiguration.type=NT_MAX;
 335     listNotificationConfigurations.push_back(tempNotificationConfiguration);
 336
 337     tempNotificationConfiguration.parameter=16;
 338     tempNotificationConfiguration.status=NS_CHANGE;
 339     tempNotificationConfiguration.type=NT_UNKNOWN;
 340     listNotificationConfigurations.push_back(tempNotificationConfiguration);
 341
 342     return (listNotificationConfigurations);
 343 }
 344
 345 void CAmCommonFunctions::connectionList2RoutingList(std::vector<am_RoutingElement_s> & routingList, const std::vector<am_Connection_s>& connectionList)
 346 {
 347     am_RoutingElement_s routingElement;
 348     std::vector<am_Connection_s>::const_iterator cIterator = connectionList.begin();
 349     for (; cIterator < connectionList.end(); ++cIterator)
 350     {
 351         routingElement.sinkID = cIterator->sinkID;
 352         routingElement.sourceID = cIterator->sourceID;
 353         routingElement.connectionFormat = cIterator->connectionFormat;
 354         routingElement.domainID = 4; //todo: make this test read out the real value
 355         routingList.push_back(routingElement);
 356     }
 357 }
 358