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

equal deleted inserted replaced

-:128eb6a32b84
+:8dfd592727cb
 #include <AudioPreference.h>
 #include "tmsutility.h"
 #include "tmsclientserver.h"
 #include "tmsshared.h"
-#include "tmsipcallstream.h"
 #include "tmscallipadpt.h"
 using namespace TMS;
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void TMSCallIPAdpt::ConstructL()
 {
 TRACE_PRN_FN_ENT;
+iIPDownlink = NULL;
 iIPUplink = NULL;
-iIPDownlink = NULL;
 iDTMFDnlinkPlayer = NULL;
 iDTMFUplinkPlayer = NULL;
 iDTMFNotifier = NULL;
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::CreateStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::CreateStream(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::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; //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; //not initialized yet!
 status = TMS_RESULT_SUCCESS;
 }
 break;
 }
 default:
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::InitStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::InitStream(TMSCallType /*callType*/, TMSStreamType strmType,
+gint TMSCallIPAdpt::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);
 guint32 fourCC = TOFOURCC(frmtType);
 if (fourCC == NULL)
 {
 return TMS_RESULT_INVALID_ARGUMENT;
 }
 {
 status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iUplinkStreamId)
 {
 SetFormat(iUplinkStreamId, fourCC);
-status = OpenUplinkL(message);
+status = OpenUplink(message, retrytime);
 if (status == TMS_RESULT_SUCCESS)
 {
 status = InitDTMF(TMS_STREAM_UPLINK);
 }
-NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iDnlinkStreamId)
 {
 SetFormat(iDnlinkStreamId, fourCC);
-status = OpenDownlinkL(message);
+status = OpenDownlink(message, retrytime);
 if (status == TMS_RESULT_SUCCESS)
 {
 status = InitDTMF(TMS_STREAM_DOWNLINK);
 }
-NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 }
 break;
 }
 default:
 {
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::StartStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::StartStream(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::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_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
-if (strmId == iUplinkStreamId && iIPUplink)
+if (iIPUplink && strmId == iUplinkStreamId)
 {
-iIPUplink->Start();
+iIPUplink->Start(retrytime);
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (strmId == iDnlinkStreamId && iIPDownlink)
+if (iIPDownlink && strmId == iDnlinkStreamId)
 {
-iIPDownlink->Start();
+iIPDownlink->Start(retrytime);
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
 }
 break;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::PauseStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::PauseStream(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::PauseStream(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::StopStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType,
+gint TMSCallIPAdpt::StopStream(const TMSCallType /*callType*/,
-gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
-if (strmId == iUplinkStreamId && iIPUplink)
+if (iIPUplink && strmId == iUplinkStreamId)
 {
 iIPUplink->Stop();
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (strmId == iDnlinkStreamId && iIPDownlink)
+if (iIPDownlink && strmId == iDnlinkStreamId)
 {
 iIPDownlink->Stop();
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DeinitStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::DeinitStream(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::DeinitStream(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
-if (strmId == iUplinkStreamId && iIPUplink)
+if (iIPUplink && strmId == iUplinkStreamId)
 {
 iIPUplink->Stop();
 //iUplinkStreamId = -1;
 iUplinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
-NotifyClient(iUplinkStreamId, ECmdDownlinkDeInitComplete,
+NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);
-status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (strmId == iDnlinkStreamId && iIPDownlink)
+if (iIPDownlink && strmId == iDnlinkStreamId)
 {
 iIPDownlink->Stop();
 //iDnlinkStreamId = -1;
 iDnlinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DeleteStream
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::DeleteStream(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::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:
 {
-// This is additional error checking
 if (strmId == iUplinkStreamId)
 {
 iUplinkStreamId = -1;
 iUplinkInitialized = FALSE;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-// This is additional error checking
 if (strmId == iDnlinkStreamId)
 {
 iDnlinkStreamId = -1;
 iDnlinkInitialized = FALSE;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DataXferBufferEmptied
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::DataXferBufferEmptied(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::DataXferBufferEmptied(const TMSCallType /*callType*/,
-TMSStreamType strmType, gint strmId)
+const TMSStreamType strmType, const gint strmId)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 switch (strmType)
 {
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DataXferBufferFilled
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::DataXferBufferFilled(TMSCallType /*callType*/,
+gint TMSCallIPAdpt::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_SUCCESS);
 switch (strmType)
 {
 //
 gint TMSCallIPAdpt::GetMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 if (iDnlinkInitialized && iIPDownlink)
 {
 status = iIPDownlink->GetMaxVolume(volume);
 iMaxVolume = volume;
 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 gint status(TMS_RESULT_INVALID_STATE);
 if (iDnlinkInitialized && iIPDownlink)
 {
 status = iIPDownlink->GetMaxVolume(volume);
 iMaxVolume = volume;
-TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume);
+TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxVolume [%d]"), volume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 //
 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
+//iGlobalVol = volume;
 if (iDnlinkInitialized && iIPDownlink)
 {
 status = iIPDownlink->SetVolume(volume);
 }
 TRACE_PRN_FN_EXT;
 gint status(TMS_RESULT_INVALID_STATE);
 if (iUplinkInitialized && iIPUplink)
 {
 status = iIPUplink->GetMaxGain(gain);
 iMaxGain = gain;
-TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain);
+TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxGain [%d]"), gain);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 //
 gint TMSCallIPAdpt::SetGlobalGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
+//iGlobalGain = gain;
 if (iUplinkInitialized && iIPUplink)
 {
 status = iIPUplink->SetGain(gain);
 }
 TRACE_PRN_FN_EXT;
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
-// TMSCallIPAdpt::OpenDownlinkL
+// TMSCallIPAdpt::OpenDownlink
 // Method for player initialization.
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::OpenDownlinkL(const RMessage2& message)
+gint TMSCallIPAdpt::OpenDownlink(const RMessage2& message, const gint retrytime)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 // Clients must have MultimediaDD capability to use this priority/pref.
 iPriority.iPref = KAudioPrefVoipAudioDownlink;
 iPriority.iPriority = KAudioPriorityVoipAudioDownlink;
 if (!iIPDownlink)
 {
-iIPDownlink = TMSIPDownlink::NewL(iDnFourCC, iPriority);
+TRAP(status, iIPDownlink = TMSIPDownlink::NewL(*this, iDnFourCC,
-}
+iPriority, retrytime));
+}
-if (iIPDownlink)
+if (iIPDownlink && status == TMS_RESULT_SUCCESS)
 {
 // Open message queue for handling server notifications to the client
 if (iMsgQueueDn.Handle() <= 0)
 {
 // Second argument in TMSCallProxy::InitStream
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
-// TMSCallIPAdpt::OpenUplinkL
+// TMSCallIPAdpt::OpenUplink
 // Method for recorder initialization.
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::OpenUplinkL(const RMessage2& message)
+gint TMSCallIPAdpt::OpenUplink(const RMessage2& message, const gint retrytime)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 // Clients must have MultimediaDD capability to use this priority/pref
 iPriority.iPref = KAudioPrefVoipAudioUplink;
 iPriority.iPriority = KAudioPriorityVoipAudioUplink;
 if (!iIPUplink)
 {
-iIPUplink = TMSIPUplink::NewL(iUpFourCC, iPriority);
+TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority,
-}
+retrytime));
+}
-if (iIPUplink)
+if (iIPUplink && status == TMS_RESULT_SUCCESS)
 {
 // Open message queue for handling server notifications to the client
 if (iMsgQueueUp.Handle() <= 0)
 {
 // Second argument in TMSCallProxy::InitStream
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output)
 {
+TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 if (iDnlinkInitialized && iIPDownlink)
 {
 TRAP(status, iIPDownlink->SetAudioDeviceL(output));
 }
+TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::GetOutput
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output)
 {
+TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 if (iDnlinkInitialized && iIPDownlink)
 {
 TRAP(status, iIPDownlink->GetAudioDeviceL(output));
 }
-return status;
+TRACE_PRN_FN_EXT;
-}
+return status;
+}
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::GetPreviousOutput
 //
 // -----------------------------------------------------------------------------
 //
 // TMSCallIPAdpt::GetAvailableOutputsL
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/,
-CBufFlat*& /*outputsbuffer*/)
+CBufFlat*& /*outputsbuf*/)
 {
 return TMS_RESULT_FEATURE_NOT_SUPPORTED;
 }
 // -----------------------------------------------------------------------------
 if (strmtype == TMS_STREAM_DOWNLINK)
 {
 delete iDTMFDnlinkPlayer;
 iDTMFDnlinkPlayer = NULL;
-/* Clarify with adaptation team which prio/pref values should be used.
-* 1) KAudioDTMFString                       -local play, no mixing
-*    KAudioPriorityDTMFString               -local play, no mixing
-* 2) KAudioPrefUnknownVoipAudioDownlink     -3rd party VoIP?
-*    KAudioPriorityUnknownVoipAudioDownlink -3rd party VoIP?
-* 3) KAudioPrefVoipAudioDownlink            -NOK native VoIP?
-*    KAudioPriorityVoipAudioDownlink        -NOK native VoIP?
-*/
 TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
-KAudioPrefVoipAudioDownlink, KAudioPriorityVoipAudioDownlink));
+KAudioDTMFString, KAudioPriorityDTMFString));
 }
 else if (strmtype == TMS_STREAM_UPLINK)
 {
 delete iDTMFUplinkPlayer;
 iDTMFUplinkPlayer = NULL;
-/* Clarify with adaptation team which prio/pref values should be used.
-* Currently the audio policy blocks DTMF mixing with the UPL stream.
-* 1) KAudioPrefUnknownVoipAudioUplink      -3rd party VoIP?
-*    KAudioPriorityUnknownVoipAudioUplink  -3rd party VoIP?
-*    KAudioPriorityUnknownVoipAudioUplinkNonSignal -???
-* 2) KAudioPrefVoipAudioUplink             -NOK native VoIP?
-*    KAudioPrefUnknownVoipAudioUplinkNonSignal -???
-*    KAudioPrefVoipAudioUplinkNonSignal        -???
-*    KAudioPriorityVoipAudioUplink         -NOK native VoIP?
-*/
 TRAP(status, iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
-KAudioPrefVoipAudioUplink, KAudioPriorityVoipAudioUplink));
+KAudioDTMFString, KAudioPriorityDTMFString));
 }
 if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS)
 {
 TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL());
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::StopDTMF(TMSStreamType streamtype)
 {
 TRACE_PRN_FN_ENT;
+gint status(TMS_RESULT_SUCCESS);
-if (streamtype == TMS_STREAM_DOWNLINK)
+if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer)
 {
 iDTMFDnlinkPlayer->Cancel();
 }
-else if (streamtype == TMS_STREAM_UPLINK)
+else if (streamtype == TMS_STREAM_UPLINK && iDTMFUplinkPlayer)
 {
+//status = iDTMFUplinkPlayer->StopDtmfTone();
 iDTMFUplinkPlayer->Cancel();
 }
 TRACE_PRN_FN_EXT;
-return TMS_RESULT_SUCCESS;
+return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::ContinueDTMF
 //
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::ContinueDTMF(gboolean /*continuesending*/)
+gint TMSCallIPAdpt::ContinueDTMF(const gboolean /*sending*/)
 {
 return TMS_RESULT_FEATURE_NOT_SUPPORTED;
 }
 //From DTMFTonePlayerObserver
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DTMFInitCompleted
 //
 // -----------------------------------------------------------------------------
 //
-void TMSCallIPAdpt::DTMFInitCompleted(gint /*error*/)
+void TMSCallIPAdpt::DTMFInitCompleted(gint /*status*/)
 {
 TRACE_PRN_FN_ENT;
-//TRACE_PRN_IF_ERR(error);
+// TODO: process error
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DTMFToneFinished
 //
 // -----------------------------------------------------------------------------
 //
-void TMSCallIPAdpt::DTMFToneFinished(gint error)
+void TMSCallIPAdpt::DTMFToneFinished(gint status)
 {
 TRACE_PRN_FN_ENT;
-TRACE_PRN_IF_ERR(error);
+TRACE_PRN_IF_ERR(status);
 TmsMsgBufPckg dtmfpckg;
-// Ignore KErrUnderflow - end of DTMF playback.
+// KErrUnderflow indicates end of DTMF playback.
-if(error == KErrUnderflow /*|| error == KErrInUse*/)
+if (status == KErrUnderflow /*|| status == KErrInUse*/)
 {
-error = TMS_RESULT_SUCCESS;
+status = TMS_RESULT_SUCCESS;
 }
-dtmfpckg().iStatus = error;
+dtmfpckg().iStatus = TMSUtility::TMSResult(status);
 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
 if (iDTMFNotifier)
 {
 iDTMFNotifier->SetDtmf(dtmfpckg);
 }
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
+// TMSCallIPAdpt::DownlinkInitCompleted
+// From TMSIPDevSoundObserver
+// -----------------------------------------------------------------------------
+//
+void TMSCallIPAdpt::DownlinkInitCompleted(gint status)
+{
+TRACE_PRN_FN_ENT;
+if (status == TMS_RESULT_SUCCESS)
+{
+iDnlinkInitialized = TRUE;
+}
+NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
+TRACE_PRN_FN_EXT;
+}
+// -----------------------------------------------------------------------------
+// TMSCallIPAdpt::UplinkInitCompleted
+// From TMSIPDevSoundObserver
+// -----------------------------------------------------------------------------
+//
+void TMSCallIPAdpt::UplinkInitCompleted(gint status)
+{
+TRACE_PRN_FN_ENT;
+if (status == TMS_RESULT_SUCCESS)
+{
+iUplinkInitialized = TRUE;
+}
+NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
+TRACE_PRN_FN_EXT;
+}
+// -----------------------------------------------------------------------------
+// TMSCallIPAdpt::UplinkStarted
+// From TMSIPDevSoundObserver
+// -----------------------------------------------------------------------------
+//
+void TMSCallIPAdpt::UplinkStarted(gint status)
+{
+TRACE_PRN_FN_ENT;
+NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
+TRACE_PRN_FN_EXT;
+}
+// -----------------------------------------------------------------------------
+// TMSCallIPAdpt::DownlinkStarted
+// From TMSIPDevSoundObserver
+// -----------------------------------------------------------------------------
+//
+void TMSCallIPAdpt::DownlinkStarted(gint status)
+{
+TRACE_PRN_FN_ENT;
+NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
+TRACE_PRN_FN_EXT;
+}
+// -----------------------------------------------------------------------------
 // TMSCallIPAdpt::NotifyClient
 // -----------------------------------------------------------------------------
 //
-void TMSCallIPAdpt::NotifyClient(const gint strmId, const gint aCommand,
+void TMSCallIPAdpt::NotifyClient(const gint strmId, const gint command,
-const gint aStatus, const gint64 /*aInt64*/)
+const gint status, const gint64 /*int64*/)
 {
-iMsgBuffer.iRequest = aCommand;
+iMsgBuffer.iRequest = command;
-iMsgBuffer.iStatus = aStatus;
+iMsgBuffer.iStatus = status;
 if (strmId == iUplinkStreamId)
 {
 iMsgQueueUp.Send(iMsgBuffer);
 }

changeset 31	8dfd592727cb
parent 22	128eb6a32b84
child 28	ebf79c79991a