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

equal deleted inserted replaced

-:94fc26b6e006
+:1fa3fb47b1e3
 #include "tmscallcsadpt.h"
 #include "tmsutility.h"
 #include "tmsshared.h"
 #include "tmsclientserver.h"
 #include "tmstarsettings.h"
-#include "tmsdtmftoneplayer.h"
+#include "tmssyncvol.h"
-#include "tmsdtmfprovider.h"
-#include "tmsdtmfnotifier.h"
 using namespace TMS;
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::NewL
 TRACE_PRN_FN_ENT;
 iCSDownlink = NULL;
 iCSUplink = NULL;
 iRouting = NULL;
 iTarSettings = NULL;
-iDTMFDnlinkPlayer = NULL;
+iResetVolNotifier = NULL;
-iDTMFUplinkPlayer = NULL;
-iDTMFNotifier = NULL;
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::TMSCallCSAdpt
 {
 TRACE_PRN_FN_ENT;
 delete iRouting;
 delete iTarSettings;
-delete iDTMFUplinkPlayer;
-delete iDTMFDnlinkPlayer;
-delete iDTMFNotifier;
 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:
 if (!iCSUplink)
 {
 TRAP(status, iCSUplink = TMSCSUplink::NewL(*this, retrytime));
 }
-if (!iDTMFUplinkPlayer && status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iDTMFUplinkPlayer = TMSDTMFProvider::NewL());
-iDTMFUplinkPlayer->AddObserver(*this);
-}
-if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL());
-}
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::InitDownlink
 TRAP(status, iRouting = CTelephonyAudioRouting::NewL(*this));
 }
 if (!iTarSettings && status == TMS_RESULT_SUCCESS)
 {
 TRAP(status, iTarSettings = TMSTarSettings::NewL());
-}
-if (!iDTMFDnlinkPlayer && status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
-KAudioDTMFString, KAudioPriorityDTMFString));
-}
-if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL());
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 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);
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (iCSDownlink && strmId == iDnlinkStreamId)
+if(!iResetVolNotifier)
+{
+TRAP(status, iResetVolNotifier = TMSSyncVol::NewL());
+}
+if(iResetVolNotifier)
+{
+iResetVolNotifier->SetSyncVol();
+}
+if (iCSDownlink && strmId == iDnlinkStreamId &&
+iDnlState == EInitialized)
 {
 iCSDownlink->Activate(retrytime);
 status = TMS_RESULT_SUCCESS;
 }
 break;
 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;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::StartDTMF
-//
-// -----------------------------------------------------------------------------
-//
-gint TMSCallCSAdpt::StartDTMF(const TMSStreamType strmtype, TDes& dtmfstring)
-{
-TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED);
-TmsMsgBufPckg dtmfpckg;
-dtmfpckg().iStatus = status;
-dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
-if (strmtype == TMS_STREAM_DOWNLINK && iDnlinkInitialized)
-{
-if (iDTMFDnlinkPlayer)
-{
-iDTMFDnlinkPlayer->PlayDtmfTone(dtmfstring);
-status = TMS_RESULT_SUCCESS;
-}
-dtmfpckg().iStatus = TMS_RESULT_SUCCESS;
-dtmfpckg().iRequest = ECmdDTMFToneDnlPlayStarted;
-}
-else if (strmtype == TMS_STREAM_UPLINK && iUplinkInitialized)
-{
-//use etel for uplink
-if (iDTMFUplinkPlayer)
-{
-status = iDTMFUplinkPlayer->SendDtmfToneString(dtmfstring);
-status = TMS_RESULT_SUCCESS;
-}
-dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status);
-dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted;
-}
-if (iDTMFNotifier)
-{
-iDTMFNotifier->SetDtmf(dtmfpckg);
-}
-TRACE_PRN_IF_ERR(status);
-TRACE_PRN_FN_EXT;
-return status;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::StopDTMF
-//
-// -----------------------------------------------------------------------------
-//
-gint TMSCallCSAdpt::StopDTMF(const TMSStreamType streamtype)
-{
-TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
-if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer)
-{
-iDTMFDnlinkPlayer->Cancel();
-}
-else if (streamtype == TMS_STREAM_UPLINK && iDTMFUplinkPlayer)
-{
-status = iDTMFUplinkPlayer->StopDtmfTone();
-status = TMSUtility::EtelToTMSResult(status);
-}
-TRACE_PRN_FN_EXT;
-return status;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::ContinueDTMF
-//
-// -----------------------------------------------------------------------------
-//
-gint TMSCallCSAdpt::ContinueDTMF(const gboolean sending)
-{
-TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iDTMFUplinkPlayer)
-{
-status = iDTMFUplinkPlayer->ContinueDtmfStringSending(sending);
-status = TMSUtility::EtelToTMSResult(status);
-}
-TRACE_PRN_FN_EXT;
-return status;
-}
-//From TMSDTMFTonePlayerObserver
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::DTMFInitCompleted
-//
-// -----------------------------------------------------------------------------
-//
-void TMSCallCSAdpt::DTMFInitCompleted(gint /*status*/)
-{
-TRACE_PRN_FN_ENT;
-// TODO: process error
-TRACE_PRN_FN_EXT;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::DTMFToneFinished
-//
-// -----------------------------------------------------------------------------
-//
-void TMSCallCSAdpt::DTMFToneFinished(gint status)
-{
-TRACE_PRN_FN_ENT;
-TRACE_PRN_IF_ERR(status);
-TmsMsgBufPckg dtmfpckg;
-// KErrUnderflow indicates end of DTMF playback.
-if (status == KErrUnderflow || status == KErrInUse)
-{
-status = TMS_RESULT_SUCCESS;
-}
-dtmfpckg().iStatus = TMSUtility::TMSResult(status);
-dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
-if (iDTMFNotifier)
-{
-iDTMFNotifier->SetDtmf(dtmfpckg);
-}
-TRACE_PRN_FN_EXT;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::HandleDTMFEvent
-//
-// -----------------------------------------------------------------------------
-//
-void TMSCallCSAdpt::HandleDTMFEvent(
-const TMSDTMFObserver::TCCPDtmfEvent event, const gint status,
-const TChar /*tone*/)
-{
-TRACE_PRN_FN_ENT;
-TmsMsgBufPckg dtmfpckg;
-TRACE_PRN_N1(_L("**TMS TMSCallCSAdpt::HandleDTMFEvent error:%d"), status);
-dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status);
-switch (event)
-{
-case ECCPDtmfUnknown:               //Unknown
-break;
-case ECCPDtmfManualStart:           //DTMF sending started manually
-case ECCPDtmfSequenceStart:         //Automatic DTMF sending initialized
-dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted;
-break;
-case ECCPDtmfManualStop:            //DTMF sending stopped manually
-case ECCPDtmfManualAbort:           //DTMF sending aborted manually
-case ECCPDtmfSequenceStop:          //Automatic DTMF sending stopped
-case ECCPDtmfSequenceAbort:         //Automatic DTMF sending aborted
-case ECCPDtmfStopInDtmfString:      //There was stop mark in DTMF string
-case ECCPDtmfStringSendingCompleted: //DTMF sending success
-dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
-break;
-default:
-break;
-}
-if (iDTMFNotifier)
-{
-iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
-}
-TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // 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;
 }
 // -----------------------------------------------------------------------------

changeset 42	1fa3fb47b1e3
parent 31	8dfd592727cb
child 55	e267340986c9