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

equal deleted inserted replaced

-:ab526b8cacfb
+:60e492b28869
 #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;
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSCallIPAdpt::TMSCallIPAdpt
 TRACE_PRN_FN_ENT;
 iCodecs.Reset();
 iCodecs.Close();
 iArrBitrates.Reset();
 delete iIPUplink;
 delete iIPDownlink;
 if (iMsgQueueUp.Handle() > 0)
 {
 // -----------------------------------------------------------------------------
 // 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 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);
-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);
-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)
 {
 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();
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status);
 }
 break;
 }
 case TMS_STREAM_DOWNLINK:
 {
-if (strmId == iDnlinkStreamId && iIPDownlink)
+if (iIPDownlink && strmId == iDnlinkStreamId)
 {
 iIPDownlink->Start();
 status = TMS_RESULT_SUCCESS;
 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status);
 }
 // -----------------------------------------------------------------------------
 // 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)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_SUCCESS);
 // Clients must have MultimediaDD capability to use this priority/pref.
 // TODO: Also, TMS will monitor for emergency call and if detected it
 //       will deny access to audio resources.
 *    KAudioPriorityVoipAudioDownlink         -NOK native VoIP?
 */
 iPriority.iPref = KAudioPrefVoipAudioDownlink;
 iPriority.iPriority = KAudioPriorityVoipAudioDownlink;
-if (!iIPDownlink)
+delete iIPDownlink;
-{
+iIPDownlink = NULL;
-iIPDownlink = TMSIPDownlink::NewL(iDnFourCC, iPriority);
+TRAP(status, iIPDownlink = TMSIPDownlink::NewL(*this, iDnFourCC,
-}
+iPriority));
-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)
 {
 TRACE_PRN_FN_ENT;
-gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
+gint status(TMS_RESULT_SUCCESS);
 // Clients must have MultimediaDD capability to use this priority/pref
 /* Clarify with adaptation team which prio/pref values should be used.
 * 1) KAudioPrefUnknownVoipAudioUplink      -3rd party VoIP?
 *    KAudioPriorityVoipAudioUplink         -NOK native VoIP?
 */
 iPriority.iPref = KAudioPrefVoipAudioUplink;
 iPriority.iPriority = KAudioPriorityVoipAudioUplink;
-if (!iIPUplink)
+delete iIPUplink;
-{
+iIPUplink = NULL;
-iIPUplink = TMSIPUplink::NewL(iUpFourCC, iPriority);
+TRAP(status, iIPUplink = TMSIPUplink::NewL(*this, iUpFourCC, iPriority));
-}
+if (iIPUplink && status == TMS_RESULT_SUCCESS)
-if (iIPUplink)
 {
 // Open message queue for handling server notifications to the client
 if (iMsgQueueUp.Handle() <= 0)
 {
 // Second argument in TMSCallProxy::InitStream
 {
 // For transfer data buffer processing
 iIPUplink->SetMsgQueue(iMsgQueueUp);
 }
 }
 TRACE_PRN_IF_ERR(status);
 TRACE_PRN_FN_EXT;
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 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;
 }
 // -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// 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);
 }

branch	RCL_3
changeset 17	60e492b28869
parent 13	bea5e7625e42
child 19	095bea5f582e