FCL/sf/mw/mmmw: comparison mmserv/tms/tmscallserver/src/tmscallcsadpt.cpp

equal deleted inserted replaced

-:095bea5f582e
+:0ac9a5310753
 #include "tmscallcsadpt.h"
 #include "tmsutility.h"
 #include "tmsshared.h"
 #include "tmsclientserver.h"
 #include "tmstarsettings.h"
-#include "tmssyncvol.h"
 using namespace TMS;
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::NewL
 TRACE_PRN_FN_ENT;
 iCSDownlink = NULL;
 iCSUplink = NULL;
 iRouting = NULL;
 iTarSettings = NULL;
-iResetVolNotifier = NULL;
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::TMSCallCSAdpt
 delete iRouting;
 delete iTarSettings;
 delete iCSUplink;
 delete iCSDownlink;
-delete iResetVolNotifier;
 if (iMsgQueueUp.Handle() > 0)
 {
 iMsgQueueUp.Close();
 }
 gint TMSCallCSAdpt::PostConstruct()
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 iNextStreamId = 1;
-iUplState = EIdle;
+iUplinkInitialized = FALSE;
-iDnlState = EIdle;
+iDnlinkInitialized = FALSE;
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
 status = TMS_RESULT_ALREADY_EXIST;
-if (iUplState == EIdle)
+if (!iUplinkInitialized)
 {
 iUplinkStreamId = iNextStreamId;
 outStrmId = iUplinkStreamId;
 iNextStreamId++;
+//iUplinkInitialized = TRUE; //not initialized yet!
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 status = TMS_RESULT_ALREADY_EXIST;
-if (iDnlState == EIdle)
+if (!iDnlinkInitialized)
 {
 iDnlinkStreamId = iNextStreamId;
 outStrmId = iDnlinkStreamId;
 iNextStreamId++;
+//iDnlinkInitialized = TRUE; //not initialized yet!
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 default:
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::InitStream(const TMSCallType /*callType*/,
 const TMSStreamType strmType, const gint strmId,
-const TMSFormatType /*frmtType*/, const gint retrytime,
+const TMSFormatType /*frmtType*/, const RMessage2& message)
-const RMessage2& message)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 switch (strmType)
 // Third argument in TMSCallProxy::InitStream
 status = iMsgQueueUp.Open(message, 1);
 }
 if (status == TMS_RESULT_SUCCESS)
 {
-status = InitUplink(retrytime);
+status = InitUplink();
 }
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 // Third argument in TMSCallProxy::InitStream
 status = iMsgQueueDn.Open(message, 1);
 }
 if (status == TMS_RESULT_SUCCESS)
 {
-status = InitDownlink(retrytime);
+status = InitDownlink();
 }
 }
 break;
 }
 default:
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::InitUplink
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::InitUplink(const gint retrytime)
+gint TMSCallCSAdpt::InitUplink()
 {
 gint status(TMS_RESULT_SUCCESS);
 if (!iCSUplink)
 {
-TRAP(status, iCSUplink = TMSCSUplink::NewL(*this, retrytime));
+TRAP(status, iCSUplink = TMSCSUplink::NewL(*this));
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::InitDownlink
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::InitDownlink(const gint retrytime)
+gint TMSCallCSAdpt::InitDownlink()
 {
 gint status(TMS_RESULT_SUCCESS);
 if (!iCSDownlink)
 {
-TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this, retrytime));
+TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this));
 }
 if (!iRouting && status == TMS_RESULT_SUCCESS)
 {
 TRAP(status, iRouting = CTelephonyAudioRouting::NewL(*this));
 }
 // TMSCallCSAdpt::StartStream
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::StartStream(const TMSCallType /*callType*/,
-const TMSStreamType strmType, const gint strmId, const gint retrytime)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
-if (iCSUplink && strmId == iUplinkStreamId &&
+if (iCSUplink && strmId == iUplinkStreamId)
-iUplState == EInitialized)
 {
-iCSUplink->Activate(retrytime);
+iCSUplink->Activate();
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if(!iResetVolNotifier)
+if (iCSDownlink && strmId == iDnlinkStreamId)
 {
-TRAP(status, iResetVolNotifier = TMSSyncVol::NewL());
+iCSDownlink->Activate();
-}
-if(iResetVolNotifier)
-{
-iResetVolNotifier->SetSyncVol();
-}
-if (iCSDownlink && strmId == iDnlinkStreamId &&
-iDnlState == EInitialized)
-{
-iCSDownlink->Activate(retrytime);
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 default:
 case TMS_STREAM_UPLINK:
 {
 if (iCSUplink && strmId == iUplinkStreamId)
 {
 iCSUplink->Deactivate();
-iUplState = EInitialized;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 if (iCSDownlink && strmId == iDnlinkStreamId)
 {
 iCSDownlink->Deactivate();
-iDnlState = EInitialized;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_UPLINK:
 {
 if (iCSUplink && strmId == iUplinkStreamId)
 {
 iCSUplink->Deactivate();
-iUplState = EIdle;
+iUplinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);
 }
 break;
-}
 case TMS_STREAM_DOWNLINK:
-{
 if (iCSDownlink && strmId == iDnlinkStreamId)
 {
 iCSDownlink->Deactivate();
-iDnlState = EIdle;
+iDnlinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,
 status);
 }
 break;
 case TMS_STREAM_UPLINK:
 {
 if (strmId == iUplinkStreamId)
 {
 iUplinkStreamId = -1;
-iUplState = EIdle;
+iUplinkInitialized = FALSE;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 if (strmId == iDnlinkStreamId)
 {
 iDnlinkStreamId = -1;
-iDnlState = EIdle;
+iDnlinkInitialized = FALSE;
 }
 break;
 }
 default:
 {
 //
 gint TMSCallCSAdpt::GetMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSDownlink && iDnlState != EIdle)
+if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->MaxVolume();
 status = TMS_RESULT_SUCCESS;
 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt: GetMaxVolume [%d]"), volume);
 }
 //
 gint TMSCallCSAdpt::SetVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSDownlink && iDnlState != EIdle)
+if (iCSDownlink && iDnlinkInitialized)
 {
 iCSDownlink->SetVolume(volume);
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status);
 }
 //
 gint TMSCallCSAdpt::GetVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSDownlink && iDnlState != EIdle)
+if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->Volume();
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallCSAdpt::GetMaxGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSUplink && iUplState != EIdle)
+if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->MaxGain();
 status = TMS_RESULT_SUCCESS;
 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetMaxGain [%d]"), gain);
 }
 //
 gint TMSCallCSAdpt::SetGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSUplink && iUplState != EIdle)
+if (iCSUplink && iUplinkInitialized)
 {
 iCSUplink->SetGain(gain);
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdSetGain, status);
 }
 //
 gint TMSCallCSAdpt::GetGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSUplink && iUplState != EIdle)
+if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->Gain();
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallCSAdpt::GetGlobalMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSDownlink && iDnlState != EIdle)
+if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->MaxVolume();
 status = TMS_RESULT_SUCCESS;
 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetGlobalMaxVolume [%d]"), volume);
 }
 gint TMSCallCSAdpt::SetGlobalVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 iGlobalVol = volume;
-if (iCSDownlink && iDnlState != EIdle)
+if (iCSDownlink && iDnlinkInitialized)
 {
 iCSDownlink->SetVolume(volume);
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallCSAdpt::GetGlobalVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSDownlink && iDnlState != EIdle)
+if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->Volume();
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallCSAdpt::GetGlobalMaxGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSUplink && iUplState != EIdle)
+if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->MaxGain();
 status = TMS_RESULT_SUCCESS;
 TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetGlobalMaxGain [%d]"), gain);
 }
 gint TMSCallCSAdpt::SetGlobalGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 iGlobalGain = gain;
-if (iCSUplink && iUplState != EIdle)
+if (iCSUplink && iUplinkInitialized)
 {
 iCSUplink->SetGain(gain);
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallCSAdpt::GetGlobalGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSUplink && iUplState != EIdle)
+if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->Gain();
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 CTelephonyAudioRouting::TAudioOutput taroutput;
 taroutput = iRouting->Output();
 status = TMS_RESULT_SUCCESS;
 output = TOTMSOUTPUT(taroutput);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 if (iRouting)
 {
 RBufWriteStream stream;
 stream.Open(*outputsbuf);
 CleanupClosePushL(stream);
 TArray<CTelephonyAudioRouting::TAudioOutput>
 availableOutputs = iRouting->AvailableOutputs();
 guint numOfItems = availableOutputs.Count();
 count = numOfItems;
 for (guint i = 0; i < numOfItems; i++)
 {
 tmsoutput = TOTMSOUTPUT(availableOutputs[i]);
 stream.WriteUint32L(tmsoutput);
 }
 CleanupStack::PopAndDestroy(&stream);
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
+// From TMSCSPDevSoundObserver
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DownlinkInitCompleted
 // From TMSCSDevSoundObserver
 // -----------------------------------------------------------------------------
 void TMSCallCSAdpt::DownlinkInitCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
 if (status == TMS_RESULT_SUCCESS)
 {
-iDnlState = EInitialized;
+iDnlinkInitialized = TRUE;
 }
 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 TRACE_PRN_FN_EXT;
 }
 void TMSCallCSAdpt::UplinkInitCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
 if (status == TMS_RESULT_SUCCESS)
 {
-iUplState = EInitialized;
+iUplinkInitialized = TRUE;
 }
 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 //
 void TMSCallCSAdpt::UplinkActivationCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
-if (status == TMS_RESULT_SUCCESS)
-{
-iUplState = EActivated;
-}
 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void TMSCallCSAdpt::DownlinkActivationCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
-if (status == TMS_RESULT_SUCCESS)
-{
-iDnlState = EActivated;
-}
 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------

branch	RCL_3
changeset 46	0ac9a5310753
parent 45	095bea5f582e