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

equal deleted inserted replaced

-:a36789189b53
+:095bea5f582e
 gint TMSCallIPAdpt::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 TMSCallIPAdpt::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);
 guint32 fourCC = TOFOURCC(frmtType);
 if (fourCC == NULL)
 {
 status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iUplinkStreamId)
 {
 SetFormat(iUplinkStreamId, fourCC);
-status = OpenUplink(message);
+status = OpenUplink(message, retrytime);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iDnlinkStreamId)
 {
 SetFormat(iDnlinkStreamId, fourCC);
-status = OpenDownlink(message);
+status = OpenDownlink(message, retrytime);
 }
 break;
 }
 default:
 {
 // TMSCallIPAdpt::StartStream
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::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 (iIPUplink && strmId == iUplinkStreamId)
+if (iIPUplink && strmId == iUplinkStreamId &&
-{
+iUplState == EInitialized)
-iIPUplink->Start();
+{
+iIPUplink->Start(retrytime);
 status = TMS_RESULT_SUCCESS;
-NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (iIPDownlink && strmId == iDnlinkStreamId)
+if (iIPDownlink && strmId == iDnlinkStreamId &&
-{
+iDnlState == EInitialized)
-iIPDownlink->Start();
+{
+iIPDownlink->Start(retrytime);
 status = TMS_RESULT_SUCCESS;
-NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
 }
 break;
 }
 default:
 {
 case TMS_STREAM_UPLINK:
 {
 if (strmId == iUplinkStreamId && iIPUplink)
 {
 iIPUplink->Stop();
+iUplState = EInitialized;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 if (strmId == iDnlinkStreamId && iIPDownlink)
 {
 iIPDownlink->Stop();
+iDnlState = EInitialized;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status);
 }
 break;
 }
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
-if (iIPUplink && strmId == iUplinkStreamId)
+if (iIPUplink && strmId == iUplinkStreamId &&
+iUplState == EActivated)
 {
 iIPUplink->Stop();
+iUplState = EInitialized;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (iIPDownlink && strmId == iDnlinkStreamId)
+if (iIPDownlink && strmId == iDnlinkStreamId &&
+iDnlState == EActivated)
 {
 iIPDownlink->Stop();
+iDnlState = EInitialized;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 }
 break;
 }
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
-if (iIPUplink && strmId == iUplinkStreamId)
+if (iIPUplink && strmId == iUplinkStreamId && iUplState != EIdle)
 {
 iIPUplink->Stop();
-//iUplinkStreamId = -1;
+iUplState = EIdle;
-iUplinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (iIPDownlink && strmId == iDnlinkStreamId)
+if (iIPDownlink && strmId == iDnlinkStreamId && iDnlState != EIdle)
 {
 iIPDownlink->Stop();
-//iDnlinkStreamId = -1;
+iDnlState = EIdle;
-iDnlinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete,
 status);
 }
 break;
 {
 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
 break;
 }
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 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 TMSCallIPAdpt::GetMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->GetMaxVolume(volume);
 iMaxVolume = volume;
 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume);
 }
 //
 gint TMSCallIPAdpt::SetVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->SetVolume(volume);
 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status);
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallIPAdpt::GetVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->GetVolume(volume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetMaxGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iUplinkInitialized && iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetMaxGain(gain);
 iMaxGain = gain;
 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain);
 }
 //
 gint TMSCallIPAdpt::SetGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iUplinkInitialized && iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->SetGain(gain);
 NotifyClient(iUplinkStreamId, ECmdSetGain, status);
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallIPAdpt::GetGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iUplinkInitialized && iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetGain(gain);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->GetMaxVolume(volume);
 iMaxVolume = volume;
 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxVolume [%d]"), volume);
 }
 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 //iGlobalVol = volume;
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->SetVolume(volume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->GetVolume(volume);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iUplinkInitialized && iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetMaxGain(gain);
 iMaxGain = gain;
 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetGlobalMaxGain [%d]"), gain);
 }
 gint TMSCallIPAdpt::SetGlobalGain(const guint gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
 //iGlobalGain = gain;
-if (iUplinkInitialized && iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->SetGain(gain);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetGlobalGain(guint& gain)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iUplinkInitialized && iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetGain(gain);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetSupportedBitrates(iArrBitrates);
 count = iArrBitrates.Count();
 }
 TRACE_PRN_FN_EXT;
 //
 gint TMSCallIPAdpt::GetBitRate(guint& bitrate)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetBitrate(bitrate);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::SetBitRate(const guint bitrate)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->SetBitrate(bitrate);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->GetVad(fmttype, vad);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPUplink)
+if (iIPUplink && iUplState != EIdle)
 {
 status = iIPUplink->SetVad(fmttype, vad);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EInitialized)
 {
 status = iIPDownlink->GetCng(fmttype, cng);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EInitialized)
 {
 status = iIPDownlink->SetCng(fmttype, cng);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->GetPlc(fmttype, plc);
 }
 TRACE_PRN_FN_EXT;
 return status;
 //
 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EInitialized)
 {
 status = iIPDownlink->SetPlc(fmttype, plc);
 }
 TRACE_PRN_FN_EXT;
 return status;
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::OpenDownlink
 // Method for player initialization.
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::OpenDownlink(const RMessage2& message)
+gint TMSCallIPAdpt::OpenDownlink(const RMessage2& message, const gint retrytime)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 // Clients must have MultimediaDD capability to use this priority/pref.
 iPriority.iPref = KAudioPrefVoipAudioDownlink;
 iPriority.iPriority = KAudioPriorityVoipAudioDownlink;
 delete iIPDownlink;
 iIPDownlink = NULL;
-TRAP(status, iIPDownlink = TMSIPDownlink::NewL(*this, iDnFourCC,
+TRAP(status, iIPDownlink = TMSIPDownlink::NewL(*this, iDnFourCC, iPriority,
-iPriority));
+retrytime));
 if (iIPDownlink && status == TMS_RESULT_SUCCESS)
 {
 // Open message queue for handling server notifications to the client
 if (iMsgQueueDn.Handle() <= 0)
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::OpenUplink
 // Method for recorder initialization.
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::OpenUplink(const RMessage2& message)
+gint TMSCallIPAdpt::OpenUplink(const RMessage2& message, const gint retrytime)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 // Clients must have MultimediaDD capability to use this priority/pref
 * 1) KAudioPrefUnknownVoipAudioUplink      -3rd party VoIP?
 *    KAudioPriorityUnknownVoipAudioUplink  -3rd party VoIP?
 * 2) KAudioPrefVoipAudioUplink             -NOK native VoIP?
 *    KAudioPriorityVoipAudioUplink         -NOK native VoIP?
 */
-iPriority.iPref = KAudioPrefVoipAudioUplink;
+iPriority.iPref = KAudioPrefVoipAudioUplinkNonSignal;
 iPriority.iPriority = KAudioPriorityVoipAudioUplink;
 delete iIPUplink;
 iIPUplink = NULL;
-TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority));
+TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority,
+retrytime));
 if (iIPUplink && status == TMS_RESULT_SUCCESS)
 {
 // Open message queue for handling server notifications to the client
 if (iMsgQueueUp.Handle() <= 0)
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode,
 const TMSStreamType strmtype)
 {
-gint status(TMS_RESULT_INVALID_ARGUMENT);
+gint status(TMS_RESULT_SUCCESS);
-if (strmtype == TMS_STREAM_DOWNLINK)
+if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
-{
+iDnlState == EInitialized)
-if (iDnlinkInitialized && iIPDownlink)
+{
-{
+status = iIPDownlink->SetIlbcCodecMode(mode);
-status = iIPDownlink->SetIlbcCodecMode(mode);
+}
-}
+else if (strmtype == TMS_STREAM_UPLINK && iIPUplink &&
-}
+iUplState == EInitialized)
-else if (strmtype == TMS_STREAM_UPLINK)
+{
-{
+status = iIPUplink->SetIlbcCodecMode(mode);
-if (iUplinkInitialized && iIPUplink)
+}
-{
+else
-status = iIPUplink->SetIlbcCodecMode(mode);
+{
-}
+status = TMS_RESULT_INVALID_STATE;
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::GetIlbcCodecMode
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype)
 {
-gint status(TMS_RESULT_INVALID_ARGUMENT);
+gint status(TMS_RESULT_SUCCESS);
-if (strmtype == TMS_STREAM_DOWNLINK)
+if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
-{
+iDnlState != EIdle)
-if (iDnlinkInitialized && iIPDownlink)
+{
-{
+status = iIPDownlink->GetIlbcCodecMode(mode);
-status = iIPDownlink->GetIlbcCodecMode(mode);
+}
-}
+else if (strmtype == TMS_STREAM_UPLINK && iIPUplink &&
-}
+iUplState != EIdle)
-else if (strmtype == TMS_STREAM_UPLINK)
+{
-{
+status = iIPUplink->GetIlbcCodecMode(mode);
-if (iUplinkInitialized && iIPUplink)
+}
-{
+else
-status = iIPUplink->GetIlbcCodecMode(mode);
+{
-}
+status = TMS_RESULT_INVALID_STATE;
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::SetG711CodecMode
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode,
 const TMSStreamType strmtype)
 {
-gint status(TMS_RESULT_INVALID_ARGUMENT);
+gint status(TMS_RESULT_SUCCESS);
-if (strmtype == TMS_STREAM_DOWNLINK)
+if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
-{
+iDnlState == EInitialized)
-if (iDnlinkInitialized && iIPDownlink)
+{
-{
+status = iIPDownlink->SetG711CodecMode(mode);
-status = iIPDownlink->SetG711CodecMode(mode);
+}
-}
+else if (strmtype == TMS_STREAM_UPLINK && iIPUplink &&
-}
+iUplState == EInitialized)
-else if (strmtype == TMS_STREAM_UPLINK)
+{
-{
+status = iIPUplink->SetG711CodecMode(mode);
-if (iUplinkInitialized && iIPUplink)
+}
-{
+else
-status = iIPUplink->SetG711CodecMode(mode);
+{
-}
+status = TMS_RESULT_INVALID_STATE;
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::GetG711CodecMode
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype)
 {
-gint status(TMS_RESULT_INVALID_ARGUMENT);
+gint status(TMS_RESULT_SUCCESS);
-if (strmtype == TMS_STREAM_DOWNLINK)
+if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
-{
+iDnlState != EIdle)
-if (iDnlinkInitialized && iIPDownlink)
+{
-{
+status = iIPDownlink->GetG711CodecMode(mode);
-status = iIPDownlink->GetG711CodecMode(mode);
+}
-}
+else if (strmtype == TMS_STREAM_UPLINK && iIPUplink &&
-}
+iUplState != EIdle)
-else if (strmtype == TMS_STREAM_UPLINK)
+{
-{
+status = iIPUplink->GetG711CodecMode(mode);
-if (iUplinkInitialized && iIPUplink)
+}
-{
+else
-status = iIPUplink->GetG711CodecMode(mode);
+{
-}
+status = TMS_RESULT_INVALID_STATE;
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::FrameModeRequiredForEC
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq)
 {
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EInitialized)
 {
 status = iIPDownlink->FrameModeRqrdForEC(frmodereq);
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode)
 {
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EInitialized)
 {
 status = iIPDownlink->SetFrameMode(frmode);
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode)
 {
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 status = iIPDownlink->GetFrameMode(frmode);
 }
 return status;
 }
 // TMSCallIPAdpt::ConcealErrorForNextBuffer
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::ConcealErrorForNextBuffer()
 {
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EActivated)
 {
 status = iIPDownlink->ConcealErrorForNextBuffer();
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::BadLsfNextBuffer()
 {
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink)
+if (iIPDownlink && iDnlState == EActivated)
 {
 status = iIPDownlink->BadLsfNextBuffer();
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 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);
+gint status(TMS_RESULT_INVALID_STATE);
-if (iDnlinkInitialized && iIPDownlink)
+if (iIPDownlink && iDnlState != EIdle)
 {
 TRAP(status, iIPDownlink->GetAudioDeviceL(output));
 }
 TRACE_PRN_FN_EXT;
 return status;
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/,
 CBufFlat*& /*outputsbuf*/)
 {
+//TODO: return public & private
 return TMS_RESULT_FEATURE_NOT_SUPPORTED;
 }
-// -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::DownlinkInitCompleted
 // From TMSIPDevSoundObserver
 // -----------------------------------------------------------------------------
 //
 void TMSCallIPAdpt::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 TMSCallIPAdpt::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 TMSCallIPAdpt::UplinkStarted(gint status)
 {
 TRACE_PRN_FN_ENT;
+if (status == TMS_RESULT_SUCCESS)
+{
+iUplState = EActivated;
+}
 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void TMSCallIPAdpt::DownlinkStarted(gint status)
 {
 TRACE_PRN_FN_ENT;
+if (status == TMS_RESULT_SUCCESS)
+{
+iDnlState = EActivated;
+}
 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 {
 iMsgQueueDn.Send(iMsgBuffer);
 }
 }
-// End of file

branch	RCL_3
changeset 45	095bea5f582e
parent 40	60e492b28869
child 46	0ac9a5310753