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