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

equal deleted inserted replaced

-:095bea5f582e
+:0ac9a5310753
 gint TMSCallIPAdpt::PostConstruct()
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_SUCCESS);
 iNextStreamId = 1;
-iUplState = EIdle;
+iUplinkInitialized = FALSE;
-iDnlState = EIdle;
+iDnlinkInitialized = FALSE;
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 switch (strmType)
 {
 case TMS_STREAM_UPLINK:
 {
 status = TMS_RESULT_ALREADY_EXIST;
-if (iUplState == EIdle)
+if (!iUplinkInitialized)
 {
 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 (iDnlState == EIdle)
+if (!iDnlinkInitialized)
 {
 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 gint retrytime,
+const TMSFormatType frmtType, const RMessage2& message)
-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, retrytime);
+status = OpenUplink(message);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 status = TMS_RESULT_DOES_NOT_EXIST;
 if (strmId == iDnlinkStreamId)
 {
 SetFormat(iDnlinkStreamId, fourCC);
-status = OpenDownlink(message, retrytime);
+status = OpenDownlink(message);
 }
 break;
 }
 default:
 {
 // TMSCallIPAdpt::StartStream
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::StartStream(const TMSCallType /*callType*/,
-const TMSStreamType strmType, const gint strmId, const gint retrytime)
+const TMSStreamType strmType, const gint strmId)
 {
 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 && iUplState != EIdle)
+if (iIPUplink && strmId == iUplinkStreamId)
 {
 iIPUplink->Stop();
-iUplState = EIdle;
+//iUplinkStreamId = -1;
+iUplinkInitialized = FALSE;
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkDeInitComplete, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (iIPDownlink && strmId == iDnlinkStreamId && iDnlState != EIdle)
+if (iIPDownlink && strmId == iDnlinkStreamId)
 {
 iIPDownlink->Stop();
-iDnlState = EIdle;
+//iDnlinkStreamId = -1;
+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;
-iUplState = EIdle;
+iUplinkInitialized = FALSE;
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
 if (strmId == iDnlinkStreamId)
 {
 iDnlinkStreamId = -1;
-iDnlState = EIdle;
+iDnlinkInitialized = FALSE;
 }
 break;
 }
 default:
 {
 //
 gint TMSCallIPAdpt::GetMaxVolume(guint& volume)
 {
 TRACE_PRN_FN_ENT;
 gint status(TMS_RESULT_INVALID_STATE);
-if (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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 (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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 (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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 (iIPUplink && iUplState != EIdle)
+if (iUplinkInitialized && iIPUplink)
 {
 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 (iIPUplink && iUplState != EIdle)
+if (iUplinkInitialized && iIPUplink)
 {
 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 (iIPUplink && iUplState != EIdle)
+if (iUplinkInitialized && iIPUplink)
 {
 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 (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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 (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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 (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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 (iIPUplink && iUplState != EIdle)
+if (iUplinkInitialized && iIPUplink)
 {
 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 (iIPUplink && iUplState != EIdle)
+if (iUplinkInitialized && iIPUplink)
 {
 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 (iIPUplink && iUplState != EIdle)
+if (iUplinkInitialized && iIPUplink)
 {
 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 && iUplState != EIdle)
+if (iIPUplink)
 {
 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 && iUplState != EIdle)
+if (iIPUplink)
 {
 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 && iUplState != EIdle)
+if (iIPUplink)
 {
 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 && iUplState != EIdle)
+if (iIPUplink)
 {
 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 && iUplState != EIdle)
+if (iIPUplink)
 {
 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 && iDnlState == EInitialized)
+if (iIPDownlink)
 {
 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 && iDnlState == EInitialized)
+if (iIPDownlink)
 {
 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 && iDnlState != EIdle)
+if (iIPDownlink)
 {
 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 && iDnlState == EInitialized)
+if (iIPDownlink)
 {
 status = iIPDownlink->SetPlc(fmttype, plc);
 }
 TRACE_PRN_FN_EXT;
 return status;
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::OpenDownlink
 // Method for player initialization.
 // -----------------------------------------------------------------------------
 //
-gint TMSCallIPAdpt::OpenDownlink(const RMessage2& message, const gint retrytime)
+gint TMSCallIPAdpt::OpenDownlink(const RMessage2& message)
 {
 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, iPriority,
+TRAP(status, iIPDownlink = TMSIPDownlink::NewL(*this, iDnFourCC,
-retrytime));
+iPriority));
 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, const gint retrytime)
+gint TMSCallIPAdpt::OpenUplink(const RMessage2& message)
 {
 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 = KAudioPrefVoipAudioUplinkNonSignal;
+iPriority.iPref = KAudioPrefVoipAudioUplink;
 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_SUCCESS);
+gint status(TMS_RESULT_INVALID_ARGUMENT);
-if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
+if (strmtype == TMS_STREAM_DOWNLINK)
-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_SUCCESS);
+gint status(TMS_RESULT_INVALID_ARGUMENT);
-if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
+if (strmtype == TMS_STREAM_DOWNLINK)
-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_SUCCESS);
+gint status(TMS_RESULT_INVALID_ARGUMENT);
-if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
+if (strmtype == TMS_STREAM_DOWNLINK)
-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_SUCCESS);
+gint status(TMS_RESULT_INVALID_ARGUMENT);
-if (strmtype == TMS_STREAM_DOWNLINK && iIPDownlink &&
+if (strmtype == TMS_STREAM_DOWNLINK)
-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_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState == EInitialized)
+if (iIPDownlink)
 {
 status = iIPDownlink->FrameModeRqrdForEC(frmodereq);
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode)
 {
-gint status(TMS_RESULT_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState == EInitialized)
+if (iIPDownlink)
 {
 status = iIPDownlink->SetFrameMode(frmode);
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode)
 {
-gint status(TMS_RESULT_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState != EIdle)
+if (iIPDownlink)
 {
 status = iIPDownlink->GetFrameMode(frmode);
 }
 return status;
 }
 // TMSCallIPAdpt::ConcealErrorForNextBuffer
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::ConcealErrorForNextBuffer()
 {
-gint status(TMS_RESULT_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState == EActivated)
+if (iIPDownlink)
 {
 status = iIPDownlink->ConcealErrorForNextBuffer();
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::BadLsfNextBuffer()
 {
-gint status(TMS_RESULT_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState == EActivated)
+if (iIPDownlink)
 {
 status = iIPDownlink->BadLsfNextBuffer();
 }
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState != EIdle)
+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_INVALID_STATE);
+gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
-if (iIPDownlink && iDnlState != EIdle)
+if (iDnlinkInitialized && iIPDownlink)
 {
 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)
 {
-iDnlState = EInitialized;
+iDnlinkInitialized = TRUE;
 }
 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status);
 TRACE_PRN_FN_EXT;
 }
 void TMSCallIPAdpt::UplinkInitCompleted(gint status)
 {
 TRACE_PRN_FN_ENT;
 if (status == TMS_RESULT_SUCCESS)
 {
-iUplState = EInitialized;
+iUplinkInitialized = TRUE;
 }
 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 46	0ac9a5310753
parent 45	095bea5f582e