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

equal deleted inserted replaced

-:128eb6a32b84
+:8dfd592727cb
 #include "tmsdtmfnotifier.h"
 using namespace TMS;
 // -----------------------------------------------------------------------------
-// TMSCallCSAdpt::TMSCallCSAdpt
+// TMSCallCSAdpt::NewL
-//
+// Symbian constructor.
 // -----------------------------------------------------------------------------
 //
-TMSCallCSAdpt::TMSCallCSAdpt()
+TMSCallCSAdpt* TMSCallCSAdpt::NewL()
 {
-TRACE_PRN_FN_ENT;
+TMSCallCSAdpt* self = new (ELeave) TMSCallCSAdpt();
+CleanupStack::PushL(self);
+self->ConstructL();
+CleanupStack::Pop(self);
+return self;
+}
+// -----------------------------------------------------------------------------
+// TMSCallCSAdpt::ConstructL
+// 2-nd phase constructor.
+// -----------------------------------------------------------------------------
+//
+void TMSCallCSAdpt::ConstructL()
+{
+TRACE_PRN_FN_ENT;
 iCSDownlink = NULL;
 iCSUplink = NULL;
 iRouting = NULL;
 iTarSettings = NULL;
 iDTMFDnlinkPlayer = NULL;
 iDTMFUplinkPlayer = NULL;
 iDTMFNotifier = NULL;
+TRACE_PRN_FN_EXT;
-TRACE_PRN_FN_EXT;
+}
+// -----------------------------------------------------------------------------
+// TMSCallCSAdpt::TMSCallCSAdpt
+//
+// -----------------------------------------------------------------------------
+//
+TMSCallCSAdpt::TMSCallCSAdpt()
+{
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::~TMSCallCSAdpt
 //
 // -----------------------------------------------------------------------------
 //
 TMSCallCSAdpt::~TMSCallCSAdpt()
 {
 TRACE_PRN_FN_ENT;
-delete iCSDownlink;
-delete iCSUplink;
 delete iRouting;
 delete iTarSettings;
+delete iDTMFUplinkPlayer;
 delete iDTMFDnlinkPlayer;
-delete iDTMFUplinkPlayer;
 delete iDTMFNotifier;
+delete iCSUplink;
+delete iCSDownlink;
 if (iMsgQueueUp.Handle() > 0)
 {
 iMsgQueueUp.Close();
 }
 if (iMsgQueueDn.Handle() > 0)
 {
 iMsgQueueDn.Close();
 }
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 iNextStreamId = 1;
 iUplinkInitialized = FALSE;
 iDnlinkInitialized = FALSE;
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::CreateStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::CreateStream(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::CreateStream(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint& outStrmId)
+const TMSStreamType strmType, gint& outStrmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
+{
 status = TMS_RESULT_ALREADY_EXIST;
 if (!iUplinkInitialized)
 {
-iUplinkInitialized = TRUE;
 iUplinkStreamId = iNextStreamId;
 outStrmId = iUplinkStreamId;
 iNextStreamId++;
-iUplinkInitialized = TRUE;
+//iUplinkInitialized = TRUE; //not initialized yet!
 status = TMS_RESULT_SUCCESS;
 }
 break;
+}
 case TMS_STREAM_DOWNLINK:
+{
 status = TMS_RESULT_ALREADY_EXIST;
 if (!iDnlinkInitialized)
 {
-iDnlinkInitialized = TRUE;
 iDnlinkStreamId = iNextStreamId;
 outStrmId = iDnlinkStreamId;
 iNextStreamId++;
-iDnlinkInitialized = TRUE;
+//iDnlinkInitialized = TRUE; //not initialized yet!
 status = TMS_RESULT_SUCCESS;
 }
 break;
+}
 default:
+{
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 break;
+}
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::InitStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::InitStream(TMSCallType /*callType*/, TMSStreamType strmType,
+gint TMSCallCSAdpt::InitStream(const TMSCallType /*callType*/,
-gint strmId, TMSFormatType /*frmtType*/, const RMessage2& message)
+const TMSStreamType strmType, const gint strmId,
+const TMSFormatType /*frmtType*/, const gint retrytime,
+const RMessage2& message)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
+status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iUplinkStreamId)
 {
 // Open message queue handling client-server communication
 if (iMsgQueueUp.Handle() <= 0)
 {
 // Third argument in TMSCallProxy::InitStream
 status = iMsgQueueUp.Open(message, 1);
 }
 if (status == TMS_RESULT_SUCCESS)
 {
-TRAP(status, iCSUplink = TMSCSUplink::NewL(*this));
+status = InitUplink(retrytime);
-if (status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iDTMFUplinkPlayer =
-TMSDTMFProvider::NewL());
-iDTMFUplinkPlayer->AddObserver(*this);
-if (!iDTMFNotifier)
-{
-TRAP(status, iDTMFNotifier =
-TMSDtmfNotifier::NewL());
-}
-}
 }
-iStrmtype = TMS_STREAM_UPLINK;
 }
-else
-{
-status = TMS_RESULT_DOES_NOT_EXIST;
-}
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
+status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iDnlinkStreamId)
 {
 // Open message queue handling client-server communication
 if (iMsgQueueDn.Handle() <= 0)
 {
 // Third argument in TMSCallProxy::InitStream
 status = iMsgQueueDn.Open(message, 1);
 }
 if (status == TMS_RESULT_SUCCESS)
 {
-TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this));
+status = InitDownlink(retrytime);
-if (status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iRouting =
-CTelephonyAudioRouting::NewL(*this));
-if (status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iTarSettings = TMSTarSettings::NewL());
-}
-if (status == TMS_RESULT_SUCCESS)
-{
-TRAP(status, iDTMFDnlinkPlayer =
-TMSAudioDtmfTonePlayer::NewL(*this,
-KAudioDTMFString,
-KAudioPriorityDTMFString));
-if (!iDTMFNotifier)
-{
-TRAP(status, iDTMFNotifier =
-TMSDtmfNotifier::NewL());
-}
-}
-}
 }
-iStrmtype = TMS_STREAM_DOWNLINK;
 }
-else
-{
-status = TMS_RESULT_DOES_NOT_EXIST;
-}
 break;
 }
 default:
 {
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
+// TMSCallCSAdpt::InitUplink
+//
+// -----------------------------------------------------------------------------
+//
+gint TMSCallCSAdpt::InitUplink(const gint retrytime)
+{
+gint status(TMS_RESULT_SUCCESS);
+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
+//
+// -----------------------------------------------------------------------------
+//
+gint TMSCallCSAdpt::InitDownlink(const gint retrytime)
+{
+gint status(TMS_RESULT_SUCCESS);
+if (!iCSDownlink)
+{
+TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this, retrytime));
+}
+if (!iRouting && status == TMS_RESULT_SUCCESS)
+{
+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;
+}
+// -----------------------------------------------------------------------------
 // TMSCallCSAdpt::StartStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::StartStream(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::StartStream(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint strmId)
+const TMSStreamType strmType, const gint strmId, const gint retrytime)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
+{
 if (iCSUplink && strmId == iUplinkStreamId)
 {
-iCSUplink->Activate();
+iCSUplink->Activate(retrytime);
+status = TMS_RESULT_SUCCESS;
 }
 break;
+}
 case TMS_STREAM_DOWNLINK:
+{
 if (iCSDownlink && strmId == iDnlinkStreamId)
 {
-iCSDownlink->Activate();
+iCSDownlink->Activate(retrytime);
+status = TMS_RESULT_SUCCESS;
 }
 break;
+}
 default:
+{
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 break;
+}
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::PauseStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::PauseStream(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::PauseStream(const TMSCallType /*callType*/,
-TMSStreamType /*strmType*/, gint /*strmId*/)
+const TMSStreamType /*strmType*/, const gint /*strmId*/)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::StopStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType,
+gint TMSCallCSAdpt::StopStream(const TMSCallType /*callType*/,
-gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
+{
 if (iCSUplink && strmId == iUplinkStreamId)
 {
 iCSUplink->Deactivate();
-NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete,
+status = TMS_RESULT_SUCCESS;
-status, 0);
+NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
 }
 break;
+}
 case TMS_STREAM_DOWNLINK:
+{
 if (iCSDownlink && strmId == iDnlinkStreamId)
 {
 iCSDownlink->Deactivate();
-NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete,
+status = TMS_RESULT_SUCCESS;
-status, 0);
+NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 }
 break;
+}
 default:
+{
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 break;
+}
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DeinitStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::DeinitStream(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::DeinitStream(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
+{
 if (iCSUplink && strmId == iUplinkStreamId)
 {
 iCSUplink->Deactivate();
 iUplinkInitialized = FALSE;
-NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete,
+status = TMS_RESULT_SUCCESS;
-status, 0);
+NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);
 }
 break;
 case TMS_STREAM_DOWNLINK:
 if (iCSDownlink && strmId == iDnlinkStreamId)
 {
 iCSDownlink->Deactivate();
 iDnlinkInitialized = FALSE;
+status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,
-status, 0);
+status);
 }
 break;
+}
 default:
+{
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 break;
+}
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DeleteStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::DeleteStream(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::DeleteStream(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
+{
 if (strmId == iUplinkStreamId)
 {
 iUplinkStreamId = -1;
 iUplinkInitialized = FALSE;
 }
 break;
+}
 case TMS_STREAM_DOWNLINK:
+{
 if (strmId == iDnlinkStreamId)
 {
 iDnlinkStreamId = -1;
 iDnlinkInitialized = FALSE;
 }
 break;
+}
 default:
+{
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 break;
+}
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DataXferBufferEmptied
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::DataXferBufferEmptied(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::DataXferBufferEmptied(const TMSCallType /*callType*/,
-TMSStreamType /*strmType*/, gint /*strmId*/)
+const TMSStreamType /*strmType*/, const gint /*strmId*/)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 TRACE_PRN_FN_EXT;
 return status;
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DataXferBufferFilled
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::DataXferBufferFilled(TMSCallType /*callType*/,
+gint TMSCallCSAdpt::DataXferBufferFilled(const TMSCallType /*callType*/,
-TMSStreamType /*strmType*/, gint /*strmId*/, guint /*datasize*/)
+const TMSStreamType /*strmType*/, const gint /*strmId*/,
+const guint /*datasize*/)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 TRACE_PRN_FN_EXT;
 return status;
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->MaxVolume();
 status = TMS_RESULT_SUCCESS;
+TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt: GetMaxVolume [%d]"), volume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::SetVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSDownlink && iDnlinkInitialized)
 {
 iCSDownlink->SetVolume(volume);
 status = TMS_RESULT_SUCCESS;
-NotifyClient(iDnlinkStreamId, ECmdSetVolume, status, 0);
+NotifyClient(iDnlinkStreamId, ECmdSetVolume, status);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->Volume();
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetMaxGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->MaxGain();
 status = TMS_RESULT_SUCCESS;
+TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetMaxGain [%d]"), gain);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::SetGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iUplinkInitialized)
+if (iCSUplink && iUplinkInitialized)
 {
 iCSUplink->SetGain(gain);
 status = TMS_RESULT_SUCCESS;
-NotifyClient(iUplinkInitialized, ECmdSetGain, status, 0);
+NotifyClient(iUplinkStreamId, ECmdSetGain, status);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->Gain();
 status = TMS_RESULT_SUCCESS;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetGlobalMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->MaxVolume();
 status = TMS_RESULT_SUCCESS;
+TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetGlobalMaxVolume [%d]"), volume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::SetGlobalVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+gint status(TMS_RESULT_INVALID_STATE);
 iGlobalVol = volume;
 if (iCSDownlink && iDnlinkInitialized)
 {
 iCSDownlink->SetVolume(volume);
 status = TMS_RESULT_SUCCESS;
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetGlobalVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSDownlink && iDnlinkInitialized)
 {
 volume = iCSDownlink->Volume();
 status = TMS_RESULT_SUCCESS;
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetGlobalMaxGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->MaxGain();
 status = TMS_RESULT_SUCCESS;
+TRACE_PRN_N1(_L("TMS->TMSCallCSAdpt::GetGlobalMaxGain [%d]"), gain);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::SetGlobalGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+gint status(TMS_RESULT_INVALID_STATE);
 iGlobalGain = gain;
 if (iCSUplink && iUplinkInitialized)
 {
 iCSUplink->SetGain(gain);
 status = TMS_RESULT_SUCCESS;
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetGlobalGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_ILLEGAL_OPERATION);
+gint status(TMS_RESULT_INVALID_STATE);
 if (iCSUplink && iUplinkInitialized)
 {
 gain = iCSUplink->Gain();
 status = TMS_RESULT_SUCCESS;
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::GetCodecMode
-//
+// No codec format in CS call
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetCodecMode(const TMSFormatType /*fmttype*/,
 const TMSStreamType /*strmtype*/, gint& /*mode*/)
 {
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::SetCodecMode
-//
+// No codec format in CS call
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::SetCodecMode(const TMSFormatType /*fmttype*/,
 const TMSStreamType /*strmtype*/, const gint /*mode*/)
 {
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::GetSupportedBitRatesCount
-//
+// No codec format in CS call
 // -----------------------------------------------------------------------------
 //
 gint TMSCallCSAdpt::GetSupportedBitRatesCount(guint& /*count*/)
 {
 TRACE_PRN_FN_ENT;
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::GetSupportedBitRates
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::GetSupportedBitRates(CBufFlat*& brbuffer)
+gint TMSCallCSAdpt::GetSupportedBitRates(CBufFlat*& /*brbuffer*/)
 {
 TRACE_PRN_FN_ENT;
-TRAPD(status, GetSupportedBitRatesL(brbuffer));
+gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 TRACE_PRN_FN_EXT;
 return status;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::GetSupportedBitRatesL
-//
-// GetSupportedBitRates implementation which can leave.
-// -----------------------------------------------------------------------------
-//
-void TMSCallCSAdpt::GetSupportedBitRatesL(CBufFlat*& /*brbuffer*/)
-{
-User::Leave(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::GetBitRate
 //
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::SetVAD
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::SetVAD(const TMSFormatType /*fmttype*/, const gboolean /*vad*/)
+gint TMSCallCSAdpt::SetVAD(const TMSFormatType /*fmttype*/,
+const gboolean /*vad*/)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 TRACE_PRN_FN_EXT;
 return status;
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::SetOutput
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::SetOutput(TMSAudioOutput output)
+gint TMSCallCSAdpt::SetOutput(const TMSAudioOutput output)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 if (iRouting)
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::GetAvailableOutputsL
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::GetAvailableOutputsL(gint& count, CBufFlat*& outputsbuffer)
+gint TMSCallCSAdpt::GetAvailableOutputsL(gint& count, CBufFlat*& outputsbuf)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 TMSAudioOutput tmsoutput;
 if (iRouting)
 {
 RBufWriteStream stream;
-stream.Open(*outputsbuffer);
+stream.Open(*outputsbuf);
 CleanupClosePushL(stream);
-TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputs =
+TArray<CTelephonyAudioRouting::TAudioOutput>
-iRouting->AvailableOutputs();
+availableOutputs = iRouting->AvailableOutputs();
 guint numOfItems = availableOutputs.Count();
 count = numOfItems;
 for (guint i = 0; i < numOfItems; i++)
 {
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::StartDTMF
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::StartDTMF(TMSStreamType strmtype, TDes& dtmfstring)
+gint TMSCallCSAdpt::StartDTMF(const TMSStreamType strmtype, TDes& dtmfstring)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_SUCCESS);
+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;
-if (iDTMFNotifier)
-{
-iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
-}
 }
 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)
-{
+if (iDTMFNotifier)
-iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
+{
-}
+iDTMFNotifier->SetDtmf(dtmfpckg);
 }
+TRACE_PRN_IF_ERR(status);
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::StopDTMF
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::StopDTMF(TMSStreamType streamtype)
+gint TMSCallCSAdpt::StopDTMF(const TMSStreamType streamtype)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer)
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::ContinueDTMF
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallCSAdpt::ContinueDTMF(gboolean continuesending)
+gint TMSCallCSAdpt::ContinueDTMF(const gboolean sending)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 if (iDTMFUplinkPlayer)
 {
-status = iDTMFUplinkPlayer->ContinueDtmfStringSending(continuesending);
+status = iDTMFUplinkPlayer->ContinueDtmfStringSending(sending);
 status = TMSUtility::EtelToTMSResult(status);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
-//From DTMFTonePlayerObserver
+//From TMSDTMFTonePlayerObserver
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DTMFInitCompleted
 //
 // -----------------------------------------------------------------------------
 //
-void TMSCallCSAdpt::DTMFInitCompleted(gint /*error*/)
+void TMSCallCSAdpt::DTMFInitCompleted(gint /*status*/)
 {
 TRACE_PRN_FN_ENT;
 // TODO: process error
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DTMFToneFinished
 //
 // -----------------------------------------------------------------------------
 //
-void TMSCallCSAdpt::DTMFToneFinished(gint error)
+void TMSCallCSAdpt::DTMFToneFinished(gint status)
 {
 TRACE_PRN_FN_ENT;
+TRACE_PRN_IF_ERR(status);
 TmsMsgBufPckg dtmfpckg;
-if (error == KErrUnderflow || error == KErrInUse)
+// KErrUnderflow indicates end of DTMF playback.
-{
+if (status == KErrUnderflow || status == KErrInUse)
-error = TMS_RESULT_SUCCESS;
+{
-}
+status = TMS_RESULT_SUCCESS;
+}
-dtmfpckg().iStatus = TMSUtility::TMSResult(error);
+dtmfpckg().iStatus = TMSUtility::TMSResult(status);
 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
 if (iDTMFNotifier)
 {
-iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
+iDTMFNotifier->SetDtmf(dtmfpckg);
 }
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::HandleDTMFEvent
 //
 // -----------------------------------------------------------------------------
 //
 void TMSCallCSAdpt::HandleDTMFEvent(
-const TMSDTMFObserver::TCCPDtmfEvent aEvent, const gint aError,
+const TMSDTMFObserver::TCCPDtmfEvent event, const gint status,
-const TChar /*aTone*/)
+const TChar /*tone*/)
 {
 TRACE_PRN_FN_ENT;
 TmsMsgBufPckg dtmfpckg;
-TRACE_PRN_N1(_L("**TMS TMSCallCSAdpt::HandleDTMFEvent error:%d"),aError);
+TRACE_PRN_N1(_L("**TMS TMSCallCSAdpt::HandleDTMFEvent error:%d"), status);
-dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(aError);
+dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status);
-switch (aEvent)
+switch (event)
 {
 case ECCPDtmfUnknown:               //Unknown
 break;
 case ECCPDtmfManualStart:           //DTMF sending started manually
 case ECCPDtmfSequenceStart:         //Automatic DTMF sending initialized
 dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted;
 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
 }
 TRACE_PRN_FN_EXT;
 }
-// From TMSCSPDevSoundObserver
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DownlinkInitCompleted
-//
+// From TMSCSDevSoundObserver
 // -----------------------------------------------------------------------------
 //
 void TMSCallCSAdpt::DownlinkInitCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
-NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status, 0);
+if (status == TMS_RESULT_SUCCESS)
+{
+iDnlinkInitialized = TRUE;
+}
+NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::UplinkInitCompleted
-//
+// From TMSCSDevSoundObserver
 // -----------------------------------------------------------------------------
 //
 void TMSCallCSAdpt::UplinkInitCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
-NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status, 0);
+if (status == TMS_RESULT_SUCCESS)
-TRACE_PRN_FN_EXT;
+{
-}
+iUplinkInitialized = TRUE;
+}
-// -----------------------------------------------------------------------------
+NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
-// TMSCallCSAdpt::UplinkActivatedSuccessfully
-//
-// -----------------------------------------------------------------------------
-//
-void TMSCallCSAdpt::UplinkActivatedSuccessfully()
-{
-TRACE_PRN_FN_ENT;
-NotifyClient(iUplinkStreamId, ECmdUplinkStarted, KErrNone, 0);
-TRACE_PRN_FN_EXT;
-}
-// -----------------------------------------------------------------------------
-// TMSCallCSAdpt::DownlinkActivatedSuccessfully
-//
-// -----------------------------------------------------------------------------
-//
-void TMSCallCSAdpt::DownlinkActivatedSuccessfully()
-{
-TRACE_PRN_FN_ENT;
-NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, KErrNone, 0);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::UplinkActivationFailed
-//
+// From TMSCSDevSoundObserver
 // -----------------------------------------------------------------------------
 //
-void TMSCallCSAdpt::UplinkActivationFailed()
+void TMSCallCSAdpt::UplinkActivationCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
-NotifyClient(iUplinkStreamId, ECmdUplinkStarted, TMS_RESULT_FATAL_ERROR, 0);
+NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::DownlinkActivationFailed
-//
+// From TMSCSDevSoundObserver
 // -----------------------------------------------------------------------------
 //
-void TMSCallCSAdpt::DownlinkActivationFailed()
+void TMSCallCSAdpt::DownlinkActivationCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
-NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted,
+NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
-TMS_RESULT_FATAL_ERROR, 0);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallCSAdpt::AvailableOutputsChanged
 // TMSCallCSAdpt::SetOutputComplete
 //
 // -----------------------------------------------------------------------------
 //
 void TMSCallCSAdpt::SetOutputComplete(
-CTelephonyAudioRouting& aTelephonyAudioRouting, gint /*aError*/)
+CTelephonyAudioRouting& aTelephonyAudioRouting, gint /*status*/)
 {
 TRACE_PRN_FN_ENT;
 TRoutingMsgBufPckg pckg;
 pckg().iEvent = TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE;
 pckg().iOutput = TOTMSOUTPUT(aTelephonyAudioRouting.Output());

changeset 31	8dfd592727cb
parent 22	128eb6a32b84
child 33	5e8b14bae8c3
child 42	1fa3fb47b1e3