Mercurial Mercurial > oss > MCL > sf > mw > mmmw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mmserv/tms/tmsserver/src/tmsserver.cpp
branchRCL_3
changeset 3 4f62049db6ac
parent 0 71ca22bcf22a
child 7 3d8c721bf319
equal deleted inserted replaced
0:71ca22bcf22a 3:4f62049db6ac 
    98         {
 
    98         {
 
    99         User::Leave(KErrPermissionDenied);
 
    99         User::Leave(KErrPermissionDenied);
 
   100         }
 
   100         }
 
   101 
   101 
   102     const TVersion version(KTMSServMajorVersionNumber,
 
   102     const TVersion version(KTMSServMajorVersionNumber,
 
   103                            KTMSServMinorVersionNumber,
 
   103             KTMSServMinorVersionNumber, KTMSServBuildVersionNumber);
 
   104                            KTMSServBuildVersionNumber);
 
       
   105 
   104 
   106     if (!User::QueryVersionSupported(version, aVersion))
 
   105     if (!User::QueryVersionSupported(version, aVersion))
 
   107         {
 
   106         {
 
   108         User::Leave(KErrNotSupported);
 
   107         User::Leave(KErrNotSupported);
 
   109         }
 
   108         }
 
   124     TRACE_PRN_FN_ENT;
 
   123     TRACE_PRN_FN_ENT;
 
   125 
   124 
   126     iShutdownTimer = TMSServerShutDown::NewL();
 
   125     iShutdownTimer = TMSServerShutDown::NewL();
 
   127     StartL(KTMSServerName);
 
   126     StartL(KTMSServerName);
 
   128     RThread().SetPriority(EPriorityRealTime);
 
   127     RThread().SetPriority(EPriorityRealTime);
 
   129     iEffectSettings = GlobalEffectsSettings::NewL();
 
   128     iEffectSettings = TMSGlobalEffectsSettings::NewL();
 
   130     iTarHandler = NULL;
 
   129     iTarHandler = NULL;
 
   131     iAudioCenRepHandler = NULL;
 
   130     iAudioCenRepHandler = NULL;
 
   132     iCurrentRouting = TMS_AUDIO_OUTPUT_NONE;
 
   131     iCurrentRouting = TMS_AUDIO_OUTPUT_NONE;
 
   133 
   132 
   134     TRACE_PRN_FN_EXT;
 
   133     TRACE_PRN_FN_EXT;
 
   227     TRACE_PRN_FN_ENT;
 
   226     TRACE_PRN_FN_ENT;
 
   228 
   227 
   229     TInt i = 0;
 
   228     TInt i = 0;
 
   230     while (i < iTMSCallServList.Count())
 
   229     while (i < iTMSCallServList.Count())
 
   231         {
 
   230         {
 
   232         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   231         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   233         if (!callThread->IsActive())
 
   232         if (!callThread->IsActive())
 
   234             {
 
   233             {
 
   235             iTMSCallServList.Remove(i);
 
   234             iTMSCallServList.Remove(i);
 
   236             delete callThread;
 
   235             delete callThread;
 
   237             }
 
   236             }
 
   256 TInt TMSServer::StartTMSCallServer(TMSCallProxyLocal& aHandle)
 
   255 TInt TMSServer::StartTMSCallServer(TMSCallProxyLocal& aHandle)
 
   257     {
 
   256     {
 
   258     TRACE_PRN_FN_ENT;
 
   257     TRACE_PRN_FN_ENT;
 
   259     TInt status = KErrNone;
 
   258     TInt status = KErrNone;
 
   260 
   259 
   261     CStartAndMonitorTMSCallThread* callServerThread = NULL;
 
   260     TMSStartAndMonitorTMSCallThread* callServerThread = NULL;
 
   262     TRAP(status, callServerThread =
 
   261     TRAP(status, callServerThread =TMSStartAndMonitorTMSCallThread::NewL(
 
   263     CStartAndMonitorTMSCallThread::NewL(const_cast<TMSServer*>(this)));
 
   262             const_cast<TMSServer*>(this)));
 
   264     if (status != KErrNone)
 
   263     if (status != KErrNone)
 
   265         {
 
   264         {
 
   266         delete callServerThread;
 
   265         delete callServerThread;
 
   267         }
 
   266         }
 
   268     else
 
   267     else
 
   313 //
 
   312 //
 
   314 void TMSServer::StartRoutingNotifierL()
 
   313 void TMSServer::StartRoutingNotifierL()
 
   315     {
 
   314     {
 
   316     if (!iTarHandler)
 
   315     if (!iTarHandler)
 
   317         {
 
   316         {
 
   318         iTarHandler = CTarEventHandler::NewL((const_cast<TMSServer*> (this)));
 
   317         iTarHandler = TMSTarEventHandler::NewL((const_cast<TMSServer*> (this)));
 
   319         }
 
   318         }
 
   320     }
 
   319     }
 
   321 
   320 
   322 // -----------------------------------------------------------------------------
 
   321 // -----------------------------------------------------------------------------
 
   323 // TMSServer::CancelRoutingNotifier
 
   322 // TMSServer::CancelRoutingNotifier
 
   390     TUint output;
 
   389     TUint output;
 
   391     TInt i = 0;
 
   390     TInt i = 0;
 
   392     TInt status(KErrNone);
 
   391     TInt status(KErrNone);
 
   393     while (i < iTMSCallServList.Count())
 
   392     while (i < iTMSCallServList.Count())
 
   394         {
 
   393         {
 
   395         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   394         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   396 
   395 
   397         if (callThread)
 
   396         if (callThread)
 
   398             {
 
   397             {
 
   399             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   398             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   400                     TMS_ROUTING_OUTPUT_GET, output);
 
   399                     TMS_ROUTING_OUTPUT_GET, output);
 
   423     TUint output;
 
   422     TUint output;
 
   424     TInt i = 0;
 
   423     TInt i = 0;
 
   425     TInt status(KErrNone);
 
   424     TInt status(KErrNone);
 
   426     while (i < iTMSCallServList.Count())
 
   425     while (i < iTMSCallServList.Count())
 
   427         {
 
   426         {
 
   428         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   427         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   429 
   428 
   430         if (callThread)
 
   429         if (callThread)
 
   431             {
 
   430             {
 
   432             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   431             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   433                     TMS_ROUTING_PREVIOUSOUTPUT_GET, output);
 
   432                     TMS_ROUTING_PREVIOUSOUTPUT_GET, output);
 
   476 
   475 
   477     TInt i = 0;
 
   476     TInt i = 0;
 
   478 
   477 
   479     while (i < iTMSCallServList.Count())
 
   478     while (i < iTMSCallServList.Count())
 
   480         {
 
   479         {
 
   481         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   480         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   482 
   481 
   483         if (callThread)
 
   482         if (callThread)
 
   484             {
 
   483             {
 
   485             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   484             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   486                     TMS_ROUTING_AVAILABLE_OUTPUT_GET, args);
 
   485                     TMS_ROUTING_AVAILABLE_OUTPUT_GET, args);
 
   721     {
 
   720     {
 
   722     TInt status(KErrNone);
 
   721     TInt status(KErrNone);
 
   723     TInt i = 0;
 
   722     TInt i = 0;
 
   724     while (i < iTMSCallServList.Count())
 
   723     while (i < iTMSCallServList.Count())
 
   725         {
 
   724         {
 
   726         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   725         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   727 
   726 
   728         if (callThread)
 
   727         if (callThread)
 
   729             {
 
   728             {
 
   730             if (!callThread->IsActive())
 
   729             if (!callThread->IsActive())
 
   731                 {
 
   730                 {
 
   756     {
 
   755     {
 
   757     TInt status(KErrNone);
 
   756     TInt status(KErrNone);
 
   758     TInt i = 0;
 
   757     TInt i = 0;
 
   759     while (i < iTMSCallServList.Count())
 
   758     while (i < iTMSCallServList.Count())
 
   760         {
 
   759         {
 
   761         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   760         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   762 
   761 
   763         if (callThread)
 
   762         if (callThread)
 
   764             {
 
   763             {
 
   765             if (!callThread->IsActive())
 
   764             if (!callThread->IsActive())
 
   766                 {
 
   765                 {
 
   832 
   831 
   833     TRACE_PRN_N(_L("TMS->RunServerL - TMS server closed"));
 
   832     TRACE_PRN_N(_L("TMS->RunServerL - TMS server closed"));
 
   834     }
 
   833     }
 
   835 
   834 
   836 // -----------------------------------------------------------------------------
 
   835 // -----------------------------------------------------------------------------
 
   837 // CStartAndMonitorTMSCallThread::CStartAndMonitorTMSCallThread
 
   836 // TMSStartAndMonitorTMSCallThread::TMSStartAndMonitorTMSCallThread
 
   838 // Perhaps we need to move this to a .cpp?
 
   837 // Perhaps we need to move this to a .cpp?
 
   839 // -----------------------------------------------------------------------------
 
   838 // -----------------------------------------------------------------------------
 
   840 //
 
   839 //
 
   841 CStartAndMonitorTMSCallThread::CStartAndMonitorTMSCallThread(
 
   840 TMSStartAndMonitorTMSCallThread::TMSStartAndMonitorTMSCallThread(
 
   842         TMSServer* aServer) :
 
   841         TMSServer* aServer) :
 
   843     CActive(EPriorityStandard),
 
   842     CActive(EPriorityStandard),
 
   844     iTMSServer(aServer)
 
   843     iTMSServer(aServer)
 
   845     {
 
   844     {
 
   846     TRACE_PRN_FN_ENT;
 
   845     TRACE_PRN_FN_ENT;
 
   847     CActiveScheduler::Add(this);
 
   846     CActiveScheduler::Add(this);
 
   848     TRACE_PRN_FN_EXT;
 
   847     TRACE_PRN_FN_EXT;
 
   849     }
 
   848     }
 
   850 
   849 
   851 // -----------------------------------------------------------------------------
 
   850 // -----------------------------------------------------------------------------
 
   852 // CStartAndMonitorTMSCallThread::~CStartAndMonitorTMSCallThread
 
   851 // TMSStartAndMonitorTMSCallThread::~TMSStartAndMonitorTMSCallThread
 
   853 //
 
   852 //
 
   854 // -----------------------------------------------------------------------------
 
   853 // -----------------------------------------------------------------------------
 
   855 //
 
   854 //
 
   856 CStartAndMonitorTMSCallThread::~CStartAndMonitorTMSCallThread()
 
   855 TMSStartAndMonitorTMSCallThread::~TMSStartAndMonitorTMSCallThread()
 
   857     {
 
   856     {
 
   858     TRACE_PRN_FN_ENT;
 
   857     TRACE_PRN_FN_ENT;
 
   859     Cancel();
 
   858     Cancel();
 
   860     TRACE_PRN_FN_EXT;
 
   859     TRACE_PRN_FN_EXT;
 
   861     }
 
   860     }
 
   862 
   861 
   863 // -----------------------------------------------------------------------------
 
   862 // -----------------------------------------------------------------------------
 
   864 // CStartAndMonitorTMSCallThread::NewL
 
   863 // TMSStartAndMonitorTMSCallThread::NewL
 
   865 //
 
   864 //
 
   866 // -----------------------------------------------------------------------------
 
   865 // -----------------------------------------------------------------------------
 
   867 //
 
   866 //
 
   868 CStartAndMonitorTMSCallThread* CStartAndMonitorTMSCallThread::NewL(
 
   867 TMSStartAndMonitorTMSCallThread* TMSStartAndMonitorTMSCallThread::NewL(
 
   869         TMSServer* aServer)
 
   868         TMSServer* aServer)
 
   870     {
 
   869     {
 
   871     TRACE_PRN_FN_ENT;
 
   870     TRACE_PRN_FN_ENT;
 
   872     CStartAndMonitorTMSCallThread* self =
 
   871     TMSStartAndMonitorTMSCallThread* self =
 
   873             new (ELeave) CStartAndMonitorTMSCallThread(aServer);
 
   872             new (ELeave) TMSStartAndMonitorTMSCallThread(aServer);
 
   874     CleanupStack::PushL(self);
 
   873     CleanupStack::PushL(self);
 
   875     self->ConstructL();
 
   874     self->ConstructL();
 
   876     CleanupStack::Pop(self);
 
   875     CleanupStack::Pop(self);
 
   877     TRACE_PRN_FN_EXT;
 
   876     TRACE_PRN_FN_EXT;
 
   878     return self;
 
   877     return self;
 
   879     }
 
   878     }
 
   880 
   879 
   881 // -----------------------------------------------------------------------------
 
   880 // -----------------------------------------------------------------------------
 
   882 // CStartAndMonitorTMSCallThread::ConstructL
 
   881 // TMSStartAndMonitorTMSCallThread::ConstructL
 
   883 //
 
   882 //
 
   884 // -----------------------------------------------------------------------------
 
   883 // -----------------------------------------------------------------------------
 
   885 //
 
   884 //
 
   886 void CStartAndMonitorTMSCallThread::ConstructL()
 
   885 void TMSStartAndMonitorTMSCallThread::ConstructL()
 
   887     {
 
   886     {
 
   888     TRACE_PRN_FN_ENT;
 
   887     TRACE_PRN_FN_ENT;
 
   889     TRACE_PRN_FN_EXT;
 
   888     TRACE_PRN_FN_EXT;
 
   890     }
 
   889     }
 
   891 
   890 
   892 // -----------------------------------------------------------------------------
 
   891 // -----------------------------------------------------------------------------
 
   893 // CStartAndMonitorTMSCallThread::StartTMSCallServer
 
   892 // TMSStartAndMonitorTMSCallThread::StartTMSCallServer
 
   894 //
 
   893 //
 
   895 // -----------------------------------------------------------------------------
 
   894 // -----------------------------------------------------------------------------
 
   896 //
 
   895 //
 
   897 TInt CStartAndMonitorTMSCallThread::StartTMSCallServer(TMSCallProxyLocal& aHndl)
 
   896 TInt TMSStartAndMonitorTMSCallThread::StartTMSCallServer(
 
       
   897         TMSCallProxyLocal& aHndl)
 
   898     {
 
   898     {
 
   899     TRACE_PRN_FN_ENT;
 
   899     TRACE_PRN_FN_ENT;
 
   900 
   900 
   901     TInt status(KErrNone);
 
   901     TInt status(KErrNone);
 
   902     TMSCallServerStartParam start(iTMSServer, iCallSrvrHndl);
 
   902     TMSCallServerStartParam start(iTMSServer, iCallSrvrHndl);
 
   948         iServerThread.Close();
 
   948         iServerThread.Close();
 
   949         iCallSrvrHndl.Close();
 
   949         iCallSrvrHndl.Close();
 
   950         return status;
 
   950         return status;
 
   951         }
 
   951         }
 
   952     aHndl.ShareProtected();
 
   952     aHndl.ShareProtected();
 
       
   953     iStatus = KRequestPending;
 
   953     iServerThread.Logon(iStatus);
 
   954     iServerThread.Logon(iStatus);
 
   954     SetActive();
 
   955     SetActive();
 
   955 
   956 
   956     TRACE_PRN_FN_EXT;
 
   957     TRACE_PRN_FN_EXT;
 
   957     return KErrNone;
 
   958     return KErrNone;
 
   958     }
 
   959     }
 
   959 
   960 
   960 // -----------------------------------------------------------------------------
 
   961 // -----------------------------------------------------------------------------
 
   961 // CStartAndMonitorTMSCallThread::RunL
 
   962 // TMSStartAndMonitorTMSCallThread::RunL
 
   962 // From CActive
 
   963 // From CActive
 
   963 // -----------------------------------------------------------------------------
 
   964 // -----------------------------------------------------------------------------
 
   964 //
 
   965 //
 
   965 void CStartAndMonitorTMSCallThread::RunL()
 
   966 void TMSStartAndMonitorTMSCallThread::RunL()
 
   966     {
 
   967     {
 
   967     TRACE_PRN_FN_ENT;
 
   968     TRACE_PRN_FN_ENT;
 
   968     iServerThread.Close();
 
   969     iServerThread.Close();
 
   969     //NOTE: This is causing a panic when closing down tms server.
 
   970     //NOTE: This is causing a panic when closing down TMS server.
 
   970     //iCallSrvrHndl.Close();
 
   971     //iCallSrvrHndl.Close();
 
   971     TRACE_PRN_FN_EXT;
 
   972     TRACE_PRN_FN_EXT;
 
   972     }
 
   973     }
 
   973 
   974 
   974 // -----------------------------------------------------------------------------
 
   975 // -----------------------------------------------------------------------------
 
   975 // CStartAndMonitorTMSCallThread::DoCancel
 
   976 // TMSStartAndMonitorTMSCallThread::DoCancel
 
   976 // From CActive
 
   977 // From CActive
 
   977 // -----------------------------------------------------------------------------
 
   978 // -----------------------------------------------------------------------------
 
   978 //
 
   979 //
 
   979 void CStartAndMonitorTMSCallThread::DoCancel()
 
   980 void TMSStartAndMonitorTMSCallThread::DoCancel()
 
   980     {
 
   981     {
 
   981     TRACE_PRN_FN_ENT;
 
   982     TRACE_PRN_FN_ENT;
 
   982     iServerThread.LogonCancel(iStatus);
 
   983     if (iServerThread.Handle())
 
       
   984         {
 
       
   985         iServerThread.LogonCancel(iStatus);
 
       
   986         User::WaitForRequest(iStatus);
 
       
   987         }
 
   983     TRACE_PRN_FN_EXT;
 
   988     TRACE_PRN_FN_EXT;
 
   984     }
 
   989     }
 
   985 
   990 
   986 // -----------------------------------------------------------------------------
 
   991 // -----------------------------------------------------------------------------
 
   987 // TMSCallProxyLocal::Open
 
   992 // TMSCallProxyLocal::Open
MCL/sf/mw/mmmw