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

equal deleted inserted replaced

-:a36789189b53
+:095bea5f582e
 #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;
-iUplinkInitialized = FALSE;
+iUplState = EIdle;
-iDnlinkInitialized = FALSE;
+iDnlState = EIdle;
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
 status = TMS_RESULT_ALREADY_EXIST;
-if (!iUplinkInitialized)
+if (iUplState == EIdle)
 {
 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 (!iDnlinkInitialized)
+if (iDnlState == EIdle)
 {
 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 RMessage2& message)
+const TMSFormatType /*frmtType*/, const gint retrytime,
+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();
+status = InitUplink(retrytime);
 }
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 // Third argument in TMSCallProxy::InitStream
 status = iMsgQueueDn.Open(message, 1);
 }
 if (status == TMS_RESULT_SUCCESS)
 {
-status = InitDownlink();
+status = InitDownlink(retrytime);
 }
 }
 break;
 }
 default:
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::InitUplink
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::InitUplink()
+gint TMSCallCSAdpt::InitUplink(const gint retrytime)
 {
 gint status(TMS_RESULT_SUCCESS);
 if (!iCSUplink)
 {
-TRAP(status, iCSUplink = TMSCSUplink::NewL(*this));
+TRAP(status, iCSUplink = TMSCSUplink::NewL(*this, retrytime));
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::InitDownlink
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::InitDownlink()
+gint TMSCallCSAdpt::InitDownlink(const gint retrytime)
 {
 gint status(TMS_RESULT_SUCCESS);
 if (!iCSDownlink)
 {
-TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this));
+TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this, retrytime));
 }
 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 TMSStreamType strmType, const gint strmId, const gint retrytime)
 {
 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();
+{
+iCSUplink->Activate(retrytime);
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (iCSDownlink && strmId == iDnlinkStreamId)
+if(!iResetVolNotifier)
 {
-iCSDownlink->Activate();
+TRAP(status, iResetVolNotifier = TMSSyncVol::NewL());
+}
+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();
-iUplinkInitialized = FALSE;
+iUplState = EIdle;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);
 }
 break;
+}
 case TMS_STREAM_DOWNLINK:
+{
 if (iCSDownlink && strmId == iDnlinkStreamId)
 {
 iCSDownlink->Deactivate();
-iDnlinkInitialized = FALSE;
+iDnlState = EIdle;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,
 status);
 }
 break;
 case TMS_STREAM_UPLINK:
 {
 if (strmId == iUplinkStreamId)
 {
 iUplinkStreamId = -1;
-iUplinkInitialized = FALSE;
+iUplState = EIdle;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 if (strmId == iDnlinkStreamId)
 {
 iDnlinkStreamId = -1;
-iDnlinkInitialized = FALSE;
+iDnlState = EIdle;
 }
 break;
 }
 default:
 {
 //
 gint TMSCallCSAdpt::GetMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iCSDownlink && iDnlinkInitialized)
+if (iCSDownlink && iDnlState != EIdle)
 {
 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 && iDnlinkInitialized)
+if (iCSDownlink && iDnlState != EIdle)
 {
 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 && iDnlinkInitialized)
+if (iCSDownlink && iDnlState != EIdle)
 {
 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 && iUplinkInitialized)
+if (iCSUplink && iUplState != EIdle)
 {
 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 && iUplinkInitialized)
+if (iCSUplink && iUplState != EIdle)
 {
 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 && iUplinkInitialized)
+if (iCSUplink && iUplState != EIdle)
 {
 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 && iDnlinkInitialized)
+if (iCSDownlink && iDnlState != EIdle)
 {
 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 && iDnlinkInitialized)
+if (iCSDownlink && iDnlState != EIdle)
 {
 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 && iDnlinkInitialized)
+if (iCSDownlink && iDnlState != EIdle)
 {
 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 && iUplinkInitialized)
+if (iCSUplink && iUplState != EIdle)
 {
 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 && iUplinkInitialized)
+if (iCSUplink && iUplState != EIdle)
 {
 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 && iUplinkInitialized)
+if (iCSUplink && iUplState != EIdle)
 {
 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)
 {
-iDnlinkInitialized = TRUE;
+iDnlState = EInitialized;
 }
 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 TRACE_PRN_FN_EXT;
 }
 void TMSCallCSAdpt::UplinkInitCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
 if (status == TMS_RESULT_SUCCESS)
 {
-iUplinkInitialized = TRUE;
+iUplState = EInitialized;
 }
 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 19	095bea5f582e
parent 17	60e492b28869
child 20	0ac9a5310753