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

equal deleted inserted replaced

-:e35735ece90c
+:3d8c721bf319
 #include <e32svr.h>
 #include <e32uid.h>
 #include <e32capability.h>
 #include "tmsutility.h"
 #include "tmsclientserver.h"
-#include "tmsserver.h"
+#include "tmstelephonycenrep.h"
 #include "tmsservershutdown.h"
 #include "tmsserversession.h"
 #include "tmscallserverstartparam.h"
 #include "tmscallserver.h"
 #include "tmscallclisrv.h"
-#include "globaleffectssettings.h"
+#include "tmsglobaleffectssettings.h"
-#include "tareventhandler.h"
+#include "tmstareventhandler.h"
-#include "cspaudiohandler.h"
+#include "tmscenrepaudiohandler.h"
+#include "tmsserver.h"
 using namespace TMS;
 // CONSTANTS
-const TInt KShutDownDelayTime = 5000000; // 5 sec delay time
+const TInt KTMSShutDownDelayTime = 1000000; // 1 sec delay time
 const TInt KOutputsArraySize = 10;
 // -----------------------------------------------------------------------------
 // TMSServer::NewL
 //
 // If session count is zero, start server shutdown
 if (iSession == 0)
 {
 iShutdownTimer->SetDelay(TTimeIntervalMicroSeconds32(
-KShutDownDelayTime));
+KTMSShutDownDelayTime));
 }
 TRACE_PRN_N1(_L("TMS->DNL: DropSession->Active Sessions: [%d]"), iSession);
 }
 // -----------------------------------------------------------------------------
 // TMSServer::SessionCount
 //
 // -----------------------------------------------------------------------------
 //
-TInt TMSServer::SessionCount()
+TInt TMSServer::SessionCount() const
 {
 return iSession;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::SetDnLinkSession
 //
 // -----------------------------------------------------------------------------
 //
-void TMSServer::SetDnLinkSession(TBool aSession)
+void TMSServer::SetDnLinkSession(const TBool aSession)
 {
 iDnlinkSession = aSession;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::SetUpLinkSession
 //
 // -----------------------------------------------------------------------------
 //
-void TMSServer::SetUpLinkSession(TBool aSession)
+void TMSServer::SetUpLinkSession(const TBool aSession)
 {
 iUplinkSession = aSession;
 }
 // -----------------------------------------------------------------------------
 iTMSCallServList.Compress();
 TMSCallProxyLocal tmsCallSessionHandle;
 User::LeaveIfError(StartTMSCallServer(tmsCallSessionHandle));
 aHandle = tmsCallSessionHandle;
 TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::StartTMSCallServer
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::StartTMSCallServer(TMSCallProxyLocal& aHandle)
 {
 TRACE_PRN_FN_ENT;
-TInt status = KErrNone;
+TInt status = TMS_RESULT_SUCCESS;
 TMSStartAndMonitorTMSCallThread* callServerThread = NULL;
 TRAP(status, callServerThread =TMSStartAndMonitorTMSCallThread::NewL(
 const_cast<TMSServer*>(this)));
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 delete callServerThread;
 }
 else
 {
 status = iTMSCallServList.Append(callServerThread);
-if (callServerThread && status == KErrNone)
+if (callServerThread && status == TMS_RESULT_SUCCESS)
 {
 status = callServerThread->StartTMSCallServer(aHandle);
 TInt count = 0;
 count = iTMSCallServList.Count();
 //
 // -----------------------------------------------------------------------------
 //
 void TMSServer::StartRoutingNotifierL()
 {
+TRACE_PRN_FN_ENT;
 if (!iTarHandler)
 {
+iTarHandlerCount = 0;
 iTarHandler = TMSTarEventHandler::NewL((const_cast<TMSServer*> (this)));
 }
+iTarHandlerCount++;
+TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::CancelRoutingNotifier
 //
 // -----------------------------------------------------------------------------
 //
 void TMSServer::CancelRoutingNotifier()
 {
-delete iTarHandler;
+if (--iTarHandlerCount <= 0)
-iTarHandler = NULL;
+{
+delete iTarHandler;
+iTarHandler = NULL;
+}
 }
 // -----------------------------------------------------------------------------
 // TMSServer::StartCenRepHandlerL
 //
 // -----------------------------------------------------------------------------
 //
 void TMSServer::StartCenRepHandlerL()
 {
+TRACE_PRN_FN_ENT;
 #ifdef _USE_TELEPHONY_CENREP_
 if (!iAudioCenRepHandler)
 {
-iAudioCenRepHandler = CSPAudioHandler::NewL(
+iAudioCenRepHandlerCount = 0;
+iAudioCenRepHandler = TMSCenRepAudioHandler::NewL(
 (const_cast<TMSServer*> (this)));
 }
+iAudioCenRepHandlerCount++;
 #endif
+TRACE_PRN_FN_EXT;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::CancelCenRepHandler
 //
 // -----------------------------------------------------------------------------
 //
 void TMSServer::CancelCenRepHandler()
 {
-delete iAudioCenRepHandler;
+if (--iAudioCenRepHandlerCount <= 0)
-iAudioCenRepHandler = NULL;
+{
+delete iAudioCenRepHandler;
+iAudioCenRepHandler = NULL;
+}
 }
 // -----------------------------------------------------------------------------
 // TMSServer::SetOutput
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::SetOutput(CSession2* /*sid*/, TInt output)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status = SendMessageToCallServ(TMS_ROUTING_OUTPUT_SET, output);
-status = SendMessageToCallServ(TMS_ROUTING_OUTPUT_SET, output);
+if (status == TMS_RESULT_SUCCESS)
-if (status == KErrNone)
 {
 iCurrentRouting = output;
 }
 TRACE_PRN_FN_EXT;
 {
 TRACE_PRN_FN_ENT;
 TUint output;
 TInt i = 0;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 while (i < iTMSCallServList.Count())
 {
 TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 if (callThread)
 {
 status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 TMS_ROUTING_OUTPUT_GET, output);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 break;
 }
 }
 i++;
 }
 TPckgBuf<TInt> p(output);
 aMessage.Write(0, p);
-aMessage.Complete(KErrNone);
+aMessage.Complete(TMS_RESULT_SUCCESS);
-TRACE_PRN_FN_EXT;
-return KErrNone;
+TRACE_PRN_FN_EXT;
+return status;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::GetPreviousOutput
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::GetPreviousOutput(const RMessage2& aMessage)
 {
 TRACE_PRN_FN_ENT;
 TUint output;
 TInt i = 0;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 while (i < iTMSCallServList.Count())
 {
 TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 if (callThread)
 {
 status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 TMS_ROUTING_PREVIOUSOUTPUT_GET, output);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 break;
 }
 }
 i++;
 }
 TPckgBuf<TInt> p(output);
 aMessage.Write(0, p);
-aMessage.Complete(KErrNone);
+aMessage.Complete(TMS_RESULT_SUCCESS);
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 void TMSServer::GetAvailableOutputsL(const RMessage2& aMessage)
 {
 TRACE_PRN_FN_ENT;
-TInt status = KErrNone;
+TInt status = TMS_RESULT_SUCCESS;
 OutputVector outputs;
 HBufC8* buf = HBufC8::NewLC(KOutputsArraySize * sizeof(TUint32));
 TPtr8 ptr = buf->Des();
 TPckgBuf<TInt> countpkg;
 TIpcArgs args;
 if (callThread)
 {
 status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 TMS_ROUTING_AVAILABLE_OUTPUT_GET, args);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 break;
 }
 }
 i++;
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::GetMaxLevel(const RMessage2& aMessage)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 TPckgBuf<TUint> pckg;
 pckg() = iEffectSettings->MaxVolume();
-if (status == KErrNone)
+if (status == TMS_RESULT_SUCCESS)
 {
 status = aMessage.Write(0, pckg);
 aMessage.Complete(status);
 }
 TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::GetLevel(const RMessage2& aMessage)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 TPckgBuf<TUint> pckg;
 TInt volume;
 switch (iCurrentRouting)
 {
 iEffectSettings->GetEarPieceVolume(volume);
 break;
 }
 pckg() = volume;
-if (status == KErrNone)
+if (status == TMS_RESULT_SUCCESS)
 {
 aMessage.Write(0, pckg);
 aMessage.Complete(status);
 }
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::SetLevel(CSession2* /*sid*/, TBool tmsclient, TInt level)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_VOL_SET, level);
-status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_VOL_SET, level);
+if (status == TMS_RESULT_SUCCESS)
-if (status == KErrNone)
 {
 switch (iCurrentRouting)
 {
 case TMS_AUDIO_OUTPUT_PUBLIC:
 case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::GetMaxGain(const RMessage2& aMessage)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 TPckgBuf<TUint> pckg;
 pckg() = iEffectSettings->MaxGain();
-if (status == KErrNone)
+if (status == TMS_RESULT_SUCCESS)
 {
 status = aMessage.Write(0, pckg);
 aMessage.Complete(status);
 }
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::GetGain(const RMessage2& aMessage)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 TPckgBuf<TUint> pckg;
 pckg() = iEffectSettings->Gain();
-if (status == KErrNone)
+if (status == TMS_RESULT_SUCCESS)
 {
 status = aMessage.Write(0, pckg);
 aMessage.Complete(status);
 }
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::SetGain(CSession2* /*sid*/, TInt level)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_GAIN_SET, level);
-status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_GAIN_SET, level);
+if (status == TMS_RESULT_SUCCESS)
-if (status == KErrNone)
 {
 iEffectSettings->SetGain(level);
 iSessionIter.SetToFirst();
 TMSServerSession* serverSession =
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::GetSupportedCodecs(const TMSStreamType strmType,
 RArray<TFourCC>*& aCodecs)
 {
+TRACE_PRN_FN_ENT;
 if (strmType == TMS_STREAM_UPLINK)
 {
 aCodecs = &iUplCodecs;
 }
 else if (strmType == TMS_STREAM_DOWNLINK)
 {
 aCodecs = &iDnlCodecs;
 }
-return KErrNone;
+TRACE_PRN_FN_EXT;
+return TMS_RESULT_SUCCESS;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::SendMessageToCallServ
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::SendMessageToCallServ(TInt func, TInt value)
 {
-TInt status(KErrNone);
+TRACE_PRN_FN_ENT;
+TInt status(TMS_RESULT_SUCCESS);
 TInt i = 0;
 while (i < iTMSCallServList.Count())
 {
 TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 }
 else
 {
 status = callThread->iTMSCallProxyLocal.SendToCallServer(
 func, value);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 break;
 }
 }
 }
 i++;
 }
+TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::SendMessageToCallServ
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::SendMessageToCallServ(TInt func, TIpcArgs args)
 {
-TInt status(KErrNone);
+TRACE_PRN_FN_ENT;
+TInt status(TMS_RESULT_SUCCESS);
 TInt i = 0;
 while (i < iTMSCallServList.Count())
 {
 TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 }
 else
 {
 status = callThread->iTMSCallProxyLocal.SendToCallServer(
 func, args);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 break;
 }
 }
 }
 i++;
 }
+TRACE_PRN_FN_EXT;
 return status;
 }
 // -----------------------------------------------------------------------------
 // TMSServer::NotifyTarClients
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSServer::NotifyTarClients(TRoutingMsgBufPckg routingpckg)
 {
+TRACE_PRN_FN_ENT;
 iCurrentRouting = routingpckg().iOutput;
 iSessionIter.SetToFirst();
 TMSServerSession* serverSession =
 static_cast<TMSServerSession*> (iSessionIter++);
 while (serverSession != NULL)
 {
 serverSession->HandleRoutingChange(routingpckg);
 serverSession = static_cast<TMSServerSession*> (iSessionIter++);
 }
-return KErrNone;
+TRACE_PRN_FN_EXT;
+return TMS_RESULT_SUCCESS;
 }
 // -----------------------------------------------------------------------------
 // RunServerL
 //
 // Create the server (leave it on the cleanup stack)
 TMSServer* server = TMSServer::NewL();
 // Initialisation complete, now signal the client
-RProcess::Rendezvous(KErrNone);
+RProcess::Rendezvous(TMS_RESULT_SUCCESS);
 // Start the scheduler and wait for client requests
 CActiveScheduler::Start();
 // Ready to exit.
 //
 TMSStartAndMonitorTMSCallThread* TMSStartAndMonitorTMSCallThread::NewL(
 TMSServer* aServer)
 {
 TRACE_PRN_FN_ENT;
 TMSStartAndMonitorTMSCallThread* self =
 new (ELeave) TMSStartAndMonitorTMSCallThread(aServer);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop(self);
 TRACE_PRN_FN_EXT;
 return self;
 }
 // -----------------------------------------------------------------------------
 TInt TMSStartAndMonitorTMSCallThread::StartTMSCallServer(
 TMSCallProxyLocal& aHndl)
 {
 TRACE_PRN_FN_ENT;
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 TMSCallServerStartParam start(iTMSServer, iCallSrvrHndl);
 const TUidType serverUid(KNullUid, KNullUid, KUidTMSCallServerUid3);
 TThreadFunction serverFunc = TMSCallServer::StartThread;
 status = iServerThread.Create(_L(""),
 KTMSCallServerInitHeapSize,
 KTMSCallServerMaxHeapSize,
 &start,
 EOwnerProcess);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 return status;
 }
 //NOTE: set priority to EPriorityRealTime or speech codec audio will choke.
 iServerThread.Resume();
 // Server will call the reciprocal static synchronise call
 }
 User::WaitForRequest(reqStatus); // wait for start or death
-if (reqStatus.Int() != KErrNone)
+if (reqStatus.Int() != TMS_RESULT_SUCCESS)
 {
 iServerThread.Close();
 iCallSrvrHndl.Close();
 return reqStatus.Int();
 }
 status = aHndl.Open(iCallSrvrHndl);
-if (status != KErrNone)
+if (status != TMS_RESULT_SUCCESS)
 {
 iServerThread.Close();
 iCallSrvrHndl.Close();
 return status;
 }
 iStatus = KRequestPending;
 iServerThread.Logon(iStatus);
 SetActive();
 TRACE_PRN_FN_EXT;
-return KErrNone;
+return TMS_RESULT_SUCCESS;
 }
 // -----------------------------------------------------------------------------
 // TMSStartAndMonitorTMSCallThread::RunL
 // From CActive
 // Perhaps we need to move this to a .cpp?
 // -----------------------------------------------------------------------------
 TInt TMSCallProxyLocal::Open(RServer2& aTMSCallServerHandle)
 {
 TRACE_PRN_FN_ENT;
 TInt status(KErrNotSupported);
 status = CreateSession(aTMSCallServerHandle,
 TVersion(KTMSCallServerMajorVersionNumber,
 KTMSCallServerMinorVersionNumber,
 KTMSCallServerBuildVersionNumber),
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSCallProxyLocal::SendToCallServer(TInt aFunc, TUint value)
 {
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 status = SendReceive(aFunc, TIpcArgs(value));
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSCallProxyLocal::SendToCallServer(TInt aFunc, TIpcArgs args)
 {
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 status = SendReceive(aFunc, args);
 return status;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSCallProxyLocal::ReceiveFromCallServer(TInt aFunc, TUint& value)
 {
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 TPckgBuf<TUint> pckg;
 TIpcArgs args(&pckg);
 status = SendReceive(aFunc, args);
-if (status == KErrNone)
+if (status == TMS_RESULT_SUCCESS)
 {
 value = pckg();
 }
 return status;
 }
 //
 // -----------------------------------------------------------------------------
 //
 TInt TMSCallProxyLocal::ReceiveFromCallServer(TInt aFunc, TIpcArgs args)
 {
-TInt status(KErrNone);
+TInt status(TMS_RESULT_SUCCESS);
 status = SendReceive(aFunc, args);
 return status;
 }
 // -----------------------------------------------------------------------------

branch	RCL_3
changeset 7	3d8c721bf319
parent 3	4f62049db6ac
child 9	f5c5c82a163e