AudioManagerDaemon/src/CAmDatabaseObserver.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  * \file CAmDatabaseObserver.cpp
  18  * For further information see http://www.genivi.org/.
  19  *
  20  */
  21
  22 #include "CAmDatabaseObserver.h"
  23 #include <string.h>
  24 #include <cassert>
  25 #include <errno.h>
  26 #include <sys/socket.h>
  27 #include <sys/ioctl.h>
  28 #include "CAmCommandSender.h"
  29 #include "CAmRoutingSender.h"
  30 #include "CAmTelnetServer.h"
  31 #include "shared/CAmDltWrapper.h"
  32 #include "shared/CAmSerializer.h"
  33
  34 namespace am {
  35
  36 CAmDatabaseObserver::CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler) :
  37         mCommandSender(iCommandSender), //
  38         mRoutingSender(iRoutingSender), //
  39         mSerializer(iSocketHandler) //
  40 {
  41     assert(mCommandSender!=0);
  42     assert(mRoutingSender!=0);
  43     assert(iSocketHandler!=0);
  44 }
  45
  46 CAmDatabaseObserver::CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler, CAmTelnetServer *iTelnetServer) :
  47         mCommandSender(iCommandSender), //
  48         mRoutingSender(iRoutingSender), //
  49         mTelnetServer(iTelnetServer), //
  50         mSerializer(iSocketHandler) //
  51 {
  52     assert(mTelnetServer!=0);
  53     assert(mCommandSender!=0);
  54     assert(mRoutingSender!=0);
  55     assert(iSocketHandler!=0);
  56 }
  57
  58 CAmDatabaseObserver::~CAmDatabaseObserver()
  59 {
  60 }
  61
  62 void CAmDatabaseObserver::newMainConnection(const am_MainConnectionType_s& mainConnection)
  63 {
  64     mSerializer.asyncCall<CAmCommandSender, const am_MainConnectionType_s>(mCommandSender, &CAmCommandSender::cbNewMainConnection, mainConnection);
  65 }
  66
  67 void CAmDatabaseObserver::removedMainConnection(const am_mainConnectionID_t mainConnection)
  68 {
  69     mSerializer.asyncCall<CAmCommandSender, const am_mainConnectionID_t>(mCommandSender, &CAmCommandSender::cbRemovedMainConnection, mainConnection);
  70 }
  71
  72 void CAmDatabaseObserver::newSink(const am_Sink_s& sink)
  73 {
  74     mRoutingSender->addSinkLookup(sink);
  75     if (sink.visible)
  76     {
  77         am_SinkType_s s;
  78         s.availability = sink.available;
  79         s.muteState = sink.muteState;
  80         s.name = sink.name;
  81         s.sinkClassID = sink.sinkClassID;
  82         s.sinkID = sink.sinkID;
  83         s.volume = sink.mainVolume;
  84         mSerializer.asyncCall<CAmCommandSender, const am_SinkType_s>(mCommandSender, &CAmCommandSender::cbNewSink, s);
  85     }
  86 }
  87
  88 void CAmDatabaseObserver::newSource(const am_Source_s& source)
  89 {
  90     mRoutingSender->addSourceLookup(source);
  91     if (source.visible)
  92     {
  93         am_SourceType_s s;
  94         s.availability = source.available;
  95         s.name = source.name;
  96         s.sourceClassID = source.sourceClassID;
  97         s.sourceID = source.sourceID;
  98         mSerializer.asyncCall<CAmCommandSender, const am_SourceType_s>(mCommandSender, &CAmCommandSender::cbNewSource, s);
  99     }
 100 }
 101
 102 void CAmDatabaseObserver::newDomain(const am_Domain_s& domain)
 103 {
 104     mRoutingSender->addDomainLookup(domain);
 105 }
 106
 107 void CAmDatabaseObserver::newGateway(const am_Gateway_s& gateway)
 108 {
 109     (void) gateway;
 110     //todo: implement something
 111 }
 112
 113 void CAmDatabaseObserver::newCrossfader(const am_Crossfader_s& crossfader)
 114 {
 115     mRoutingSender->addCrossfaderLookup(crossfader);
 116 }
 117
 118 void CAmDatabaseObserver::removedSink(const am_sinkID_t sinkID, const bool visible)
 119 {
 120     mRoutingSender->removeSinkLookup(sinkID);
 121
 122     if (visible)
 123         mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t>(mCommandSender, &CAmCommandSender::cbRemovedSink, sinkID);
 124 }
 125
 126 void CAmDatabaseObserver::removedSource(const am_sourceID_t sourceID, const bool visible)
 127 {
 128     mRoutingSender->removeSourceLookup(sourceID);
 129
 130     if (visible)
 131         mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t>(mCommandSender, &CAmCommandSender::cbRemovedSource, sourceID);
 132 }
 133
 134 void CAmDatabaseObserver::removeDomain(const am_domainID_t domainID)
 135 {
 136     mRoutingSender->removeDomainLookup(domainID);
 137 }
 138
 139 void CAmDatabaseObserver::removeGateway(const am_gatewayID_t gatewayID)
 140 {
 141     (void) gatewayID;
 142     //todo: implement something?
 143 }
 144
 145 void CAmDatabaseObserver::removeCrossfader(const am_crossfaderID_t crossfaderID)
 146 {
 147     mRoutingSender->removeCrossfaderLookup(crossfaderID);
 148 }
 149
 150 void CAmDatabaseObserver::numberOfSinkClassesChanged()
 151 {
 152     mSerializer.asyncCall<CAmCommandSender>(mCommandSender, &CAmCommandSender::cbNumberOfSinkClassesChanged);
 153 }
 154
 155 void CAmDatabaseObserver::numberOfSourceClassesChanged()
 156 {
 157     mSerializer.asyncCall<CAmCommandSender>(mCommandSender, &CAmCommandSender::cbNumberOfSourceClassesChanged);
 158 }
 159
 160 void CAmDatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
 161 {
 162     mSerializer.asyncCall<CAmCommandSender, const am_connectionID_t, const am_ConnectionState_e>(mCommandSender, &CAmCommandSender::cbMainConnectionStateChanged, connectionID, connectionState);
 163 }
 164
 165 void CAmDatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
 166 {
 167     mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_MainSoundProperty_s&>(mCommandSender, &CAmCommandSender::cbMainSinkSoundPropertyChanged, sinkID, SoundProperty);
 168 }
 169
 170 void CAmDatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s & SoundProperty)
 171 {
 172     mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_MainSoundProperty_s&>(mCommandSender, &CAmCommandSender::cbMainSourceSoundPropertyChanged, sourceID, SoundProperty);
 173 }
 174
 175 void CAmDatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
 176 {
 177     mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_Availability_s&>(mCommandSender, &CAmCommandSender::cbSinkAvailabilityChanged, sinkID, availability);
 178 }
 179
 180 void CAmDatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
 181 {
 182     mSerializer.asyncCall<CAmCommandSender, const am_sourceID_t, const am_Availability_s&>(mCommandSender, &CAmCommandSender::cbSourceAvailabilityChanged, sourceID, availability);
 183 }
 184
 185 void CAmDatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
 186 {
 187     mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_mainVolume_t>(mCommandSender, &CAmCommandSender::cbVolumeChanged, sinkID, volume);
 188 }
 189
 190 void CAmDatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 191 {
 192     mSerializer.asyncCall<CAmCommandSender, const am_sinkID_t, const am_MuteState_e>(mCommandSender, &CAmCommandSender::cbSinkMuteStateChanged, sinkID, muteState);
 193 }
 194
 195 void CAmDatabaseObserver::systemPropertyChanged(const am_SystemProperty_s& SystemProperty)
 196 {
 197     mSerializer.asyncCall<CAmCommandSender, const am_SystemProperty_s&>(mCommandSender, &CAmCommandSender::cbSystemPropertyChanged, SystemProperty);
 198 }
 199
 200 void CAmDatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
 201 {
 202     mSerializer.asyncCall<CAmCommandSender, const am_mainConnectionID_t, const am_timeSync_t>(mCommandSender, &CAmCommandSender::cbTimingInformationChanged, mainConnection, time);
 203 }
 204 }