Mercurial Mercurial > oss > FCL > 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
changeset 12 5a06f39ad45b
parent 0 71ca22bcf22a
child 14 80975da52420
equal deleted inserted replaced
0:71ca22bcf22a 12:5a06f39ad45b 
    16  */
 
    16  */
 
    17 
    17 
    18 #include <e32svr.h>
 
    18 #include <e32svr.h>
 
    19 #include <e32uid.h>
 
    19 #include <e32uid.h>
 
    20 #include <e32capability.h>
 
    20 #include <e32capability.h>
 
       
    21 #include <AudioPreference.h>
 
    21 #include "tmsutility.h"
 
    22 #include "tmsutility.h"
 
    22 #include "tmsclientserver.h"
 
    23 #include "tmsclientserver.h"
 
    23 #include "tmsserver.h"
 
    24 #include "tmstelephonycenrep.h"
 
    24 #include "tmsservershutdown.h"
 
    25 #include "tmsservershutdown.h"
 
    25 #include "tmsserversession.h"
 
    26 #include "tmsserversession.h"
 
    26 #include "tmscallserverstartparam.h"
 
    27 #include "tmscallserverstartparam.h"
 
    27 #include "tmscallserver.h"
 
    28 #include "tmscallserver.h"
 
    28 #include "tmscallclisrv.h"
 
    29 #include "tmscallclisrv.h"
 
    29 #include "globaleffectssettings.h"
 
    30 #include "tmsglobaleffectssettings.h"
 
    30 #include "tareventhandler.h"
 
    31 #include "tmstareventhandler.h"
 
    31 #include "cspaudiohandler.h"
 
    32 #include "tmscenrepaudiohandler.h"
 
       
    33 #include "tmsdtmfeventhandler.h"
 
       
    34 #include "tmsrtparam.h"
 
       
    35 #include "tmsserver.h"
 
    32 
    36 
    33 using namespace TMS;
 
    37 using namespace TMS;
 
    34 
    38 
    35 // CONSTANTS
 
    39 // CONSTANTS
 
    36 const TInt KShutDownDelayTime = 5000000; // 5 sec delay time
 
    40 const TInt KTMSShutDownDelayTime = 1000000; // 1 sec delay time
 
    37 const TInt KOutputsArraySize = 10;
 
    41 const TInt KOutputsArraySize = 10;
 
    38 
    42 
    39 // -----------------------------------------------------------------------------
 
    43 // -----------------------------------------------------------------------------
 
    40 // TMSServer::NewL
 
    44 // TMSServer::NewL
 
    41 //
 
    45 //
 
    78     iUplCodecs.Reset();
 
    82     iUplCodecs.Reset();
 
    79     iUplCodecs.Close();
 
    83     iUplCodecs.Close();
 
    80     delete iEffectSettings;
 
    84     delete iEffectSettings;
 
    81     CancelRoutingNotifier();
 
    85     CancelRoutingNotifier();
 
    82     CancelCenRepHandler();
 
    86     CancelCenRepHandler();
 
       
    87     CancelDTMFNotifier();
 
       
    88     DeinitRingTonePlayer();
 
       
    89     delete iTMSRtPlayer;
 
    83 
    90 
    84     TRACE_PRN_FN_EXT;
 
    91     TRACE_PRN_FN_EXT;
 
    85     }
 
    92     }
 
    86 
    93 
    87 // -----------------------------------------------------------------------------
 
    94 // -----------------------------------------------------------------------------
 
    98         {
 
   105         {
 
    99         User::Leave(KErrPermissionDenied);
 
   106         User::Leave(KErrPermissionDenied);
 
   100         }
 
   107         }
 
   101 
   108 
   102     const TVersion version(KTMSServMajorVersionNumber,
 
   109     const TVersion version(KTMSServMajorVersionNumber,
 
   103                            KTMSServMinorVersionNumber,
 
   110             KTMSServMinorVersionNumber, KTMSServBuildVersionNumber);
 
   104                            KTMSServBuildVersionNumber);
 
       
   105 
   111 
   106     if (!User::QueryVersionSupported(version, aVersion))
 
   112     if (!User::QueryVersionSupported(version, aVersion))
 
   107         {
 
   113         {
 
   108         User::Leave(KErrNotSupported);
 
   114         User::Leave(KErrNotSupported);
 
   109         }
 
   115         }
 
   124     TRACE_PRN_FN_ENT;
 
   130     TRACE_PRN_FN_ENT;
 
   125 
   131 
   126     iShutdownTimer = TMSServerShutDown::NewL();
 
   132     iShutdownTimer = TMSServerShutDown::NewL();
 
   127     StartL(KTMSServerName);
 
   133     StartL(KTMSServerName);
 
   128     RThread().SetPriority(EPriorityRealTime);
 
   134     RThread().SetPriority(EPriorityRealTime);
 
   129     iEffectSettings = GlobalEffectsSettings::NewL();
 
   135     iEffectSettings = TMSGlobalEffectsSettings::NewL();
 
   130     iTarHandler = NULL;
 
   136     iTarHandler = NULL;
 
   131     iAudioCenRepHandler = NULL;
 
   137     iAudioCenRepHandler = NULL;
 
       
   138     iDTMFHandler = NULL;
 
   132     iCurrentRouting = TMS_AUDIO_OUTPUT_NONE;
 
   139     iCurrentRouting = TMS_AUDIO_OUTPUT_NONE;
 
       
   140     InitRingTonePlayerL();
 
   133 
   141 
   134     TRACE_PRN_FN_EXT;
 
   142     TRACE_PRN_FN_EXT;
 
   135     }
 
   143     }
 
   136 
   144 
   137 // -----------------------------------------------------------------------------
 
   145 // -----------------------------------------------------------------------------
 
   159 
   167 
   160     // If session count is zero, start server shutdown
 
   168     // If session count is zero, start server shutdown
 
   161     if (iSession == 0)
 
   169     if (iSession == 0)
 
   162         {
 
   170         {
 
   163         iShutdownTimer->SetDelay(TTimeIntervalMicroSeconds32(
 
   171         iShutdownTimer->SetDelay(TTimeIntervalMicroSeconds32(
 
   164                 KShutDownDelayTime));
 
   172                 KTMSShutDownDelayTime));
 
   165         }
 
   173         }
 
   166 
   174 
   167     TRACE_PRN_N1(_L("TMS->DNL: DropSession->Active Sessions: [%d]"), iSession);
 
   175     TRACE_PRN_N1(_L("TMS->DNL: DropSession->Active Sessions: [%d]"), iSession);
 
   168     }
 
   176     }
 
   169 
   177 
   170 // -----------------------------------------------------------------------------
 
   178 // -----------------------------------------------------------------------------
 
   171 // TMSServer::SessionCount
 
   179 // TMSServer::SessionCount
 
   172 //
 
   180 //
 
   173 // -----------------------------------------------------------------------------
 
   181 // -----------------------------------------------------------------------------
 
   174 //
 
   182 //
 
   175 TInt TMSServer::SessionCount()
 
   183 TInt TMSServer::SessionCount() const
 
   176     {
 
   184     {
 
   177     return iSession;
 
   185     return iSession;
 
   178     }
 
   186     }
 
   179 
   187 
   180 // -----------------------------------------------------------------------------
 
   188 // -----------------------------------------------------------------------------
 
   181 // TMSServer::SetDnLinkSession
 
   189 // TMSServer::SetDnLinkSession
 
   182 //
 
   190 //
 
   183 // -----------------------------------------------------------------------------
 
   191 // -----------------------------------------------------------------------------
 
   184 //
 
   192 //
 
   185 void TMSServer::SetDnLinkSession(TBool aSession)
 
   193 void TMSServer::SetDnLinkSession(const TBool aSession)
 
   186     {
 
   194     {
 
   187     iDnlinkSession = aSession;
 
   195     iDnlinkSession = aSession;
 
   188     }
 
   196     }
 
   189 
   197 
   190 // -----------------------------------------------------------------------------
 
   198 // -----------------------------------------------------------------------------
 
   191 // TMSServer::SetUpLinkSession
 
   199 // TMSServer::SetUpLinkSession
 
   192 //
 
   200 //
 
   193 // -----------------------------------------------------------------------------
 
   201 // -----------------------------------------------------------------------------
 
   194 //
 
   202 //
 
   195 void TMSServer::SetUpLinkSession(TBool aSession)
 
   203 void TMSServer::SetUpLinkSession(const TBool aSession)
 
   196     {
 
   204     {
 
   197     iUplinkSession = aSession;
 
   205     iUplinkSession = aSession;
 
   198     }
 
   206     }
 
   199 
   207 
   200 // -----------------------------------------------------------------------------
 
   208 // -----------------------------------------------------------------------------
 
   227     TRACE_PRN_FN_ENT;
 
   235     TRACE_PRN_FN_ENT;
 
   228 
   236 
   229     TInt i = 0;
 
   237     TInt i = 0;
 
   230     while (i < iTMSCallServList.Count())
 
   238     while (i < iTMSCallServList.Count())
 
   231         {
 
   239         {
 
   232         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   240         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   233         if (!callThread->IsActive())
 
   241         if (!callThread->IsActive())
 
   234             {
 
   242             {
 
   235             iTMSCallServList.Remove(i);
 
   243             iTMSCallServList.Remove(i);
 
   236             delete callThread;
 
   244             delete callThread;
 
   237             }
 
   245             }
 
   243     iTMSCallServList.Compress();
 
   251     iTMSCallServList.Compress();
 
   244 
   252 
   245     TMSCallProxyLocal tmsCallSessionHandle;
 
   253     TMSCallProxyLocal tmsCallSessionHandle;
 
   246     User::LeaveIfError(StartTMSCallServer(tmsCallSessionHandle));
 
   254     User::LeaveIfError(StartTMSCallServer(tmsCallSessionHandle));
 
   247     aHandle = tmsCallSessionHandle;
 
   255     aHandle = tmsCallSessionHandle;
 
       
   256 
   248     TRACE_PRN_FN_EXT;
 
   257     TRACE_PRN_FN_EXT;
 
   249     }
 
   258     }
 
   250 
   259 
   251 // -----------------------------------------------------------------------------
 
   260 // -----------------------------------------------------------------------------
 
   252 // TMSServer::StartTMSCallServer
 
   261 // TMSServer::StartTMSCallServer
 
   254 // -----------------------------------------------------------------------------
 
   263 // -----------------------------------------------------------------------------
 
   255 //
 
   264 //
 
   256 TInt TMSServer::StartTMSCallServer(TMSCallProxyLocal& aHandle)
 
   265 TInt TMSServer::StartTMSCallServer(TMSCallProxyLocal& aHandle)
 
   257     {
 
   266     {
 
   258     TRACE_PRN_FN_ENT;
 
   267     TRACE_PRN_FN_ENT;
 
   259     TInt status = KErrNone;
 
   268 
   260 
   269     TInt status = TMS_RESULT_SUCCESS;
 
   261     CStartAndMonitorTMSCallThread* callServerThread = NULL;
 
   270     TMSStartAndMonitorTMSCallThread* callServerThread = NULL;
 
   262     TRAP(status, callServerThread =
 
   271     TRAP(status, callServerThread =TMSStartAndMonitorTMSCallThread::NewL(
 
   263     CStartAndMonitorTMSCallThread::NewL(const_cast<TMSServer*>(this)));
 
   272             const_cast<TMSServer*>(this)));
 
   264     if (status != KErrNone)
 
   273     if (status != TMS_RESULT_SUCCESS)
 
   265         {
 
   274         {
 
   266         delete callServerThread;
 
   275         delete callServerThread;
 
   267         }
 
   276         }
 
   268     else
 
   277     else
 
   269         {
 
   278         {
 
   270         status = iTMSCallServList.Append(callServerThread);
 
   279         status = iTMSCallServList.Append(callServerThread);
 
   271         if (callServerThread && status == KErrNone)
 
   280         if (callServerThread && status == TMS_RESULT_SUCCESS)
 
   272             {
 
   281             {
 
   273             status = callServerThread->StartTMSCallServer(aHandle);
 
   282             status = callServerThread->StartTMSCallServer(aHandle);
 
   274             TInt count = 0;
 
   283             TInt count = 0;
 
   275             count = iTMSCallServList.Count();
 
   284             count = iTMSCallServList.Count();
 
   276 
   285 
   311 //
 
   320 //
 
   312 // -----------------------------------------------------------------------------
 
   321 // -----------------------------------------------------------------------------
 
   313 //
 
   322 //
 
   314 void TMSServer::StartRoutingNotifierL()
 
   323 void TMSServer::StartRoutingNotifierL()
 
   315     {
 
   324     {
 
       
   325     TRACE_PRN_FN_ENT;
 
       
   326 
   316     if (!iTarHandler)
 
   327     if (!iTarHandler)
 
   317         {
 
   328         {
 
   318         iTarHandler = CTarEventHandler::NewL((const_cast<TMSServer*> (this)));
 
   329         iTarHandlerCount = 0;
 
   319         }
 
   330         iTarHandler = TMSTarEventHandler::NewL((const_cast<TMSServer*> (this)));
 
       
   331         }
 
       
   332     iTarHandlerCount++;
 
       
   333 
       
   334     TRACE_PRN_FN_EXT;
 
   320     }
 
   335     }
 
   321 
   336 
   322 // -----------------------------------------------------------------------------
 
   337 // -----------------------------------------------------------------------------
 
   323 // TMSServer::CancelRoutingNotifier
 
   338 // TMSServer::CancelRoutingNotifier
 
   324 //
 
   339 //
 
   325 // -----------------------------------------------------------------------------
 
   340 // -----------------------------------------------------------------------------
 
   326 //
 
   341 //
 
   327 void TMSServer::CancelRoutingNotifier()
 
   342 void TMSServer::CancelRoutingNotifier()
 
   328     {
 
   343     {
 
   329     delete iTarHandler;
 
   344     if (--iTarHandlerCount <= 0)
 
   330     iTarHandler = NULL;
 
   345         {
 
       
   346         delete iTarHandler;
 
       
   347         iTarHandler = NULL;
 
       
   348         }
 
   331     }
 
   349     }
 
   332 
   350 
   333 // -----------------------------------------------------------------------------
 
   351 // -----------------------------------------------------------------------------
 
   334 // TMSServer::StartCenRepHandlerL
 
   352 // TMSServer::StartCenRepHandlerL
 
   335 //
 
   353 //
 
   336 // -----------------------------------------------------------------------------
 
   354 // -----------------------------------------------------------------------------
 
   337 //
 
   355 //
 
   338 void TMSServer::StartCenRepHandlerL()
 
   356 void TMSServer::StartCenRepHandlerL()
 
   339     {
 
   357     {
 
       
   358     TRACE_PRN_FN_ENT;
 
       
   359 
   340 #ifdef _USE_TELEPHONY_CENREP_
 
   360 #ifdef _USE_TELEPHONY_CENREP_
 
   341     if (!iAudioCenRepHandler)
 
   361     if (!iAudioCenRepHandler)
 
   342         {
 
   362         {
 
   343         iAudioCenRepHandler = CSPAudioHandler::NewL(
 
   363         iAudioCenRepHandlerCount = 0;
 
       
   364         iAudioCenRepHandler = TMSCenRepAudioHandler::NewL(
 
   344                 (const_cast<TMSServer*> (this)));
 
   365                 (const_cast<TMSServer*> (this)));
 
   345         }
 
   366         }
 
       
   367     iAudioCenRepHandlerCount++;
 
   346 #endif
 
   368 #endif
 
       
   369 
       
   370     TRACE_PRN_FN_EXT;
 
   347     }
 
   371     }
 
   348 
   372 
   349 // -----------------------------------------------------------------------------
 
   373 // -----------------------------------------------------------------------------
 
   350 // TMSServer::CancelCenRepHandler
 
   374 // TMSServer::CancelCenRepHandler
 
   351 //
 
   375 //
 
   352 // -----------------------------------------------------------------------------
 
   376 // -----------------------------------------------------------------------------
 
   353 //
 
   377 //
 
   354 void TMSServer::CancelCenRepHandler()
 
   378 void TMSServer::CancelCenRepHandler()
 
   355     {
 
   379     {
 
   356     delete iAudioCenRepHandler;
 
   380     if (--iAudioCenRepHandlerCount <= 0)
 
   357     iAudioCenRepHandler = NULL;
 
   381         {
 
       
   382         delete iAudioCenRepHandler;
 
       
   383         iAudioCenRepHandler = NULL;
 
       
   384         }
 
       
   385     }
 
       
   386 
       
   387 // -----------------------------------------------------------------------------
 
       
   388 // TMSServer::StartDTMFNotifierL
 
       
   389 //
 
       
   390 // -----------------------------------------------------------------------------
 
       
   391 //
 
       
   392 void TMSServer::StartDTMFNotifierL()
 
       
   393     {
 
       
   394     TRACE_PRN_FN_ENT;
 
       
   395 
       
   396     if (!iDTMFHandler)
 
       
   397         {
 
       
   398         iDTMFHandlerCount = 0;
 
       
   399         iDTMFHandler = TMSDtmfEventHandler::NewL(
 
       
   400                 (const_cast<TMSServer*> (this)));
 
       
   401         }
 
       
   402     iDTMFHandlerCount++;
 
       
   403 
       
   404     TRACE_PRN_FN_EXT;
 
       
   405     }
 
       
   406 
       
   407 // -----------------------------------------------------------------------------
 
       
   408 // TMSServer::CancelDTMFNotifier
 
       
   409 //
 
       
   410 // -----------------------------------------------------------------------------
 
       
   411 //
 
       
   412 void TMSServer::CancelDTMFNotifier()
 
       
   413     {
 
       
   414     if (--iDTMFHandlerCount <= 0)
 
       
   415         {
 
       
   416         delete iDTMFHandler;
 
       
   417         iDTMFHandler = NULL;
 
       
   418         }
 
   358     }
 
   419     }
 
   359 
   420 
   360 // -----------------------------------------------------------------------------
 
   421 // -----------------------------------------------------------------------------
 
   361 // TMSServer::SetOutput
 
   422 // TMSServer::SetOutput
 
   362 //
 
   423 //
 
   363 // -----------------------------------------------------------------------------
 
   424 // -----------------------------------------------------------------------------
 
   364 //
 
   425 //
 
   365 TInt TMSServer::SetOutput(CSession2* /*sid*/, TInt output)
 
   426 TInt TMSServer::SetOutput(CSession2* /*sid*/, TInt output)
 
   366     {
 
   427     {
 
   367     TRACE_PRN_FN_ENT;
 
   428     TRACE_PRN_FN_ENT;
 
   368     TInt status(KErrNone);
 
   429 
   369 
   430     TInt status = SendMessageToCallServ(TMS_ROUTING_OUTPUT_SET, output);
 
   370     status = SendMessageToCallServ(TMS_ROUTING_OUTPUT_SET, output);
 
   431     if (status == TMS_RESULT_SUCCESS)
 
   371 
       
   372     if (status == KErrNone)
 
       
   373         {
 
   432         {
 
   374         iCurrentRouting = output;
 
   433         iCurrentRouting = output;
 
   375         }
 
   434         }
 
   376 
   435 
   377     TRACE_PRN_FN_EXT;
 
   436     TRACE_PRN_FN_EXT;
 
   387     {
 
   446     {
 
   388     TRACE_PRN_FN_ENT;
 
   447     TRACE_PRN_FN_ENT;
 
   389 
   448 
   390     TUint output;
 
   449     TUint output;
 
   391     TInt i = 0;
 
   450     TInt i = 0;
 
   392     TInt status(KErrNone);
 
   451     TInt status(TMS_RESULT_SUCCESS);
 
   393     while (i < iTMSCallServList.Count())
 
   452     while (i < iTMSCallServList.Count())
 
   394         {
 
   453         {
 
   395         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   454         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   396 
   455 
   397         if (callThread)
 
   456         if (callThread)
 
   398             {
 
   457             {
 
   399             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   458             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   400                     TMS_ROUTING_OUTPUT_GET, output);
 
   459                     TMS_ROUTING_OUTPUT_GET, output);
 
   401             if (status != KErrNone)
 
   460             if (status != TMS_RESULT_SUCCESS)
 
   402                 {
 
   461                 {
 
   403                 break;
 
   462                 break;
 
   404                 }
 
   463                 }
 
   405             }
 
   464             }
 
   406         i++;
 
   465         i++;
 
   407         }
 
   466         }
 
   408     TPckgBuf<TInt> p(output);
 
   467     TPckgBuf<TInt> p(output);
 
   409     aMessage.Write(0, p);
 
   468     aMessage.Write(0, p);
 
   410     aMessage.Complete(KErrNone);
 
   469     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   411     TRACE_PRN_FN_EXT;
 
   470 
   412     return KErrNone;
 
   471     TRACE_PRN_FN_EXT;
 
       
   472     return status;
 
   413     }
 
   473     }
 
   414 
   474 
   415 // -----------------------------------------------------------------------------
 
   475 // -----------------------------------------------------------------------------
 
   416 // TMSServer::GetPreviousOutput
 
   476 // TMSServer::GetPreviousOutput
 
   417 //
 
   477 //
 
   418 // -----------------------------------------------------------------------------
 
   478 // -----------------------------------------------------------------------------
 
   419 //
 
   479 //
 
   420 TInt TMSServer::GetPreviousOutput(const RMessage2& aMessage)
 
   480 TInt TMSServer::GetPreviousOutput(const RMessage2& aMessage)
 
   421     {
 
   481     {
 
   422     TRACE_PRN_FN_ENT;
 
   482     TRACE_PRN_FN_ENT;
 
       
   483 
   423     TUint output;
 
   484     TUint output;
 
   424     TInt i = 0;
 
   485     TInt i = 0;
 
   425     TInt status(KErrNone);
 
   486     TInt status(TMS_RESULT_SUCCESS);
 
   426     while (i < iTMSCallServList.Count())
 
   487     while (i < iTMSCallServList.Count())
 
   427         {
 
   488         {
 
   428         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   489         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   429 
   490 
   430         if (callThread)
 
   491         if (callThread)
 
   431             {
 
   492             {
 
   432             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   493             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   433                     TMS_ROUTING_PREVIOUSOUTPUT_GET, output);
 
   494                     TMS_ROUTING_PREVIOUSOUTPUT_GET, output);
 
   434             if (status != KErrNone)
 
   495             if (status != TMS_RESULT_SUCCESS)
 
   435                 {
 
   496                 {
 
   436                 break;
 
   497                 break;
 
   437                 }
 
   498                 }
 
   438             }
 
   499             }
 
   439         i++;
 
   500         i++;
 
   440         }
 
   501         }
 
   441     TPckgBuf<TInt> p(output);
 
   502     TPckgBuf<TInt> p(output);
 
   442     aMessage.Write(0, p);
 
   503     aMessage.Write(0, p);
 
   443     aMessage.Complete(KErrNone);
 
   504     aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   505 
   444     TRACE_PRN_FN_EXT;
 
   506     TRACE_PRN_FN_EXT;
 
   445     return status;
 
   507     return status;
 
   446     }
 
   508     }
 
   447 
   509 
   448 // -----------------------------------------------------------------------------
 
   510 // -----------------------------------------------------------------------------
 
   463 //
 
   525 //
 
   464 void TMSServer::GetAvailableOutputsL(const RMessage2& aMessage)
 
   526 void TMSServer::GetAvailableOutputsL(const RMessage2& aMessage)
 
   465     {
 
   527     {
 
   466     TRACE_PRN_FN_ENT;
 
   528     TRACE_PRN_FN_ENT;
 
   467 
   529 
   468     TInt status = KErrNone;
 
   530     TInt status = TMS_RESULT_SUCCESS;
 
   469     OutputVector outputs;
 
   531     OutputVector outputs;
 
   470     HBufC8* buf = HBufC8::NewLC(KOutputsArraySize * sizeof(TUint32));
 
   532     HBufC8* buf = HBufC8::NewLC(KOutputsArraySize * sizeof(TUint32));
 
   471     TPtr8 ptr = buf->Des();
 
   533     TPtr8 ptr = buf->Des();
 
   472     TPckgBuf<TInt> countpkg;
 
   534     TPckgBuf<TInt> countpkg;
 
   473     TIpcArgs args;
 
   535     TIpcArgs args;
 
   476 
   538 
   477     TInt i = 0;
 
   539     TInt i = 0;
 
   478 
   540 
   479     while (i < iTMSCallServList.Count())
 
   541     while (i < iTMSCallServList.Count())
 
   480         {
 
   542         {
 
   481         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   543         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   482 
   544 
   483         if (callThread)
 
   545         if (callThread)
 
   484             {
 
   546             {
 
   485             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   547             status = callThread->iTMSCallProxyLocal.ReceiveFromCallServer(
 
   486                     TMS_ROUTING_AVAILABLE_OUTPUT_GET, args);
 
   548                     TMS_ROUTING_AVAILABLE_OUTPUT_GET, args);
 
   487             if (status != KErrNone)
 
   549             if (status != TMS_RESULT_SUCCESS)
 
   488                 {
 
   550                 {
 
   489                 break;
 
   551                 break;
 
   490                 }
 
   552                 }
 
   491             }
 
   553             }
 
   492         i++;
 
   554         i++;
 
   507 // -----------------------------------------------------------------------------
 
   569 // -----------------------------------------------------------------------------
 
   508 //
 
   570 //
 
   509 TInt TMSServer::GetMaxLevel(const RMessage2& aMessage)
 
   571 TInt TMSServer::GetMaxLevel(const RMessage2& aMessage)
 
   510     {
 
   572     {
 
   511     TRACE_PRN_FN_ENT;
 
   573     TRACE_PRN_FN_ENT;
 
   512     TInt status(KErrNone);
 
   574 
       
   575     TInt status(TMS_RESULT_SUCCESS);
 
   513     TPckgBuf<TUint> pckg;
 
   576     TPckgBuf<TUint> pckg;
 
   514 
   577 
   515     pckg() = iEffectSettings->MaxVolume();
 
   578     pckg() = iEffectSettings->MaxVolume();
 
   516     if (status == KErrNone)
 
   579     if (status == TMS_RESULT_SUCCESS)
 
   517         {
 
   580         {
 
   518         status = aMessage.Write(0, pckg);
 
   581         status = aMessage.Write(0, pckg);
 
   519         aMessage.Complete(status);
 
   582         aMessage.Complete(status);
 
   520         }
 
   583         }
 
       
   584 
   521     TRACE_PRN_FN_EXT;
 
   585     TRACE_PRN_FN_EXT;
 
   522     return status;
 
   586     return status;
 
   523     }
 
   587     }
 
   524 
   588 
   525 // -----------------------------------------------------------------------------
 
   589 // -----------------------------------------------------------------------------
 
   528 // -----------------------------------------------------------------------------
 
   592 // -----------------------------------------------------------------------------
 
   529 //
 
   593 //
 
   530 TInt TMSServer::GetLevel(const RMessage2& aMessage)
 
   594 TInt TMSServer::GetLevel(const RMessage2& aMessage)
 
   531     {
 
   595     {
 
   532     TRACE_PRN_FN_ENT;
 
   596     TRACE_PRN_FN_ENT;
 
   533     TInt status(KErrNone);
 
   597 
       
   598     TInt status(TMS_RESULT_SUCCESS);
 
   534     TPckgBuf<TUint> pckg;
 
   599     TPckgBuf<TUint> pckg;
 
   535     TInt volume;
 
   600     TInt volume;
 
   536 
   601 
   537     switch (iCurrentRouting)
 
   602     switch (iCurrentRouting)
 
   538         {
 
   603         {
 
   544             iEffectSettings->GetEarPieceVolume(volume);
 
   609             iEffectSettings->GetEarPieceVolume(volume);
 
   545             break;
 
   610             break;
 
   546         }
 
   611         }
 
   547 
   612 
   548     pckg() = volume;
 
   613     pckg() = volume;
 
   549     if (status == KErrNone)
 
   614     if (status == TMS_RESULT_SUCCESS)
 
   550         {
 
   615         {
 
   551         aMessage.Write(0, pckg);
 
   616         aMessage.Write(0, pckg);
 
   552         aMessage.Complete(status);
 
   617         aMessage.Complete(status);
 
   553         }
 
   618         }
 
   554 
   619 
   562 // -----------------------------------------------------------------------------
 
   627 // -----------------------------------------------------------------------------
 
   563 //
 
   628 //
 
   564 TInt TMSServer::SetLevel(CSession2* /*sid*/, TBool tmsclient, TInt level)
 
   629 TInt TMSServer::SetLevel(CSession2* /*sid*/, TBool tmsclient, TInt level)
 
   565     {
 
   630     {
 
   566     TRACE_PRN_FN_ENT;
 
   631     TRACE_PRN_FN_ENT;
 
   567     TInt status(KErrNone);
 
   632 
   568 
   633     TInt status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_VOL_SET, level);
 
   569     status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_VOL_SET, level);
 
   634     if (status == TMS_RESULT_SUCCESS)
 
   570 
       
   571     if (status == KErrNone)
 
       
   572         {
 
   635         {
 
   573         switch (iCurrentRouting)
 
   636         switch (iCurrentRouting)
 
   574             {
 
   637             {
 
   575             case TMS_AUDIO_OUTPUT_PUBLIC:
 
   638             case TMS_AUDIO_OUTPUT_PUBLIC:
 
   576             case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
 
   639             case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
 
   623 // -----------------------------------------------------------------------------
 
   686 // -----------------------------------------------------------------------------
 
   624 //
 
   687 //
 
   625 TInt TMSServer::GetMaxGain(const RMessage2& aMessage)
 
   688 TInt TMSServer::GetMaxGain(const RMessage2& aMessage)
 
   626     {
 
   689     {
 
   627     TRACE_PRN_FN_ENT;
 
   690     TRACE_PRN_FN_ENT;
 
   628     TInt status(KErrNone);
 
   691 
       
   692     TInt status(TMS_RESULT_SUCCESS);
 
   629     TPckgBuf<TUint> pckg;
 
   693     TPckgBuf<TUint> pckg;
 
   630 
       
   631     pckg() = iEffectSettings->MaxGain();
 
   694     pckg() = iEffectSettings->MaxGain();
 
   632     if (status == KErrNone)
 
   695     if (status == TMS_RESULT_SUCCESS)
 
   633         {
 
   696         {
 
   634         status = aMessage.Write(0, pckg);
 
   697         status = aMessage.Write(0, pckg);
 
   635         aMessage.Complete(status);
 
   698         aMessage.Complete(status);
 
   636         }
 
   699         }
 
   637 
   700 
   645 // -----------------------------------------------------------------------------
 
   708 // -----------------------------------------------------------------------------
 
   646 //
 
   709 //
 
   647 TInt TMSServer::GetGain(const RMessage2& aMessage)
 
   710 TInt TMSServer::GetGain(const RMessage2& aMessage)
 
   648     {
 
   711     {
 
   649     TRACE_PRN_FN_ENT;
 
   712     TRACE_PRN_FN_ENT;
 
   650     TInt status(KErrNone);
 
   713 
       
   714     TInt status(TMS_RESULT_SUCCESS);
 
   651     TPckgBuf<TUint> pckg;
 
   715     TPckgBuf<TUint> pckg;
 
   652 
       
   653     pckg() = iEffectSettings->Gain();
 
   716     pckg() = iEffectSettings->Gain();
 
   654     if (status == KErrNone)
 
   717     if (status == TMS_RESULT_SUCCESS)
 
   655         {
 
   718         {
 
   656         status = aMessage.Write(0, pckg);
 
   719         status = aMessage.Write(0, pckg);
 
   657         aMessage.Complete(status);
 
   720         aMessage.Complete(status);
 
   658         }
 
   721         }
 
   659 
   722 
   667 // -----------------------------------------------------------------------------
 
   730 // -----------------------------------------------------------------------------
 
   668 //
 
   731 //
 
   669 TInt TMSServer::SetGain(CSession2* /*sid*/, TInt level)
 
   732 TInt TMSServer::SetGain(CSession2* /*sid*/, TInt level)
 
   670     {
 
   733     {
 
   671     TRACE_PRN_FN_ENT;
 
   734     TRACE_PRN_FN_ENT;
 
   672     TInt status(KErrNone);
 
   735 
   673 
   736     TInt status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_GAIN_SET, level);
 
   674     status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_GAIN_SET, level);
 
   737     if (status == TMS_RESULT_SUCCESS)
 
   675 
       
   676     if (status == KErrNone)
 
       
   677         {
 
   738         {
 
   678         iEffectSettings->SetGain(level);
 
   739         iEffectSettings->SetGain(level);
 
   679         iSessionIter.SetToFirst();
 
   740         iSessionIter.SetToFirst();
 
   680 
   741 
   681         TMSServerSession* serverSession =
 
   742         TMSServerSession* serverSession =
 
   699 // -----------------------------------------------------------------------------
 
   760 // -----------------------------------------------------------------------------
 
   700 //
 
   761 //
 
   701 TInt TMSServer::GetSupportedCodecs(const TMSStreamType strmType,
 
   762 TInt TMSServer::GetSupportedCodecs(const TMSStreamType strmType,
 
   702         RArray<TFourCC>*& aCodecs)
 
   763         RArray<TFourCC>*& aCodecs)
 
   703     {
 
   764     {
 
       
   765     TRACE_PRN_FN_ENT;
 
       
   766 
   704     if (strmType == TMS_STREAM_UPLINK)
 
   767     if (strmType == TMS_STREAM_UPLINK)
 
   705         {
 
   768         {
 
   706         aCodecs = &iUplCodecs;
 
   769         aCodecs = &iUplCodecs;
 
   707         }
 
   770         }
 
   708     else if (strmType == TMS_STREAM_DOWNLINK)
 
   771     else if (strmType == TMS_STREAM_DOWNLINK)
 
   709         {
 
   772         {
 
   710         aCodecs = &iDnlCodecs;
 
   773         aCodecs = &iDnlCodecs;
 
   711         }
 
   774         }
 
   712     return KErrNone;
 
   775 
       
   776     TRACE_PRN_FN_EXT;
 
       
   777     return TMS_RESULT_SUCCESS;
 
   713     }
 
   778     }
 
   714 
   779 
   715 // -----------------------------------------------------------------------------
 
   780 // -----------------------------------------------------------------------------
 
   716 // TMSServer::SendMessageToCallServ
 
   781 // TMSServer::SendMessageToCallServ
 
   717 //
 
   782 //
 
   718 // -----------------------------------------------------------------------------
 
   783 // -----------------------------------------------------------------------------
 
   719 //
 
   784 //
 
   720 TInt TMSServer::SendMessageToCallServ(TInt func, TInt value)
 
   785 TInt TMSServer::SendMessageToCallServ(TInt func, TInt value)
 
   721     {
 
   786     {
 
   722     TInt status(KErrNone);
 
   787     TRACE_PRN_FN_ENT;
 
       
   788 
       
   789     TInt status(TMS_RESULT_SUCCESS);
 
   723     TInt i = 0;
 
   790     TInt i = 0;
 
   724     while (i < iTMSCallServList.Count())
 
   791     while (i < iTMSCallServList.Count())
 
   725         {
 
   792         {
 
   726         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   793         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   727 
   794 
   728         if (callThread)
 
   795         if (callThread)
 
   729             {
 
   796             {
 
   730             if (!callThread->IsActive())
 
   797             if (!callThread->IsActive())
 
   731                 {
 
   798                 {
 
   734                 }
 
   801                 }
 
   735             else
 
   802             else
 
   736                 {
 
   803                 {
 
   737                 status = callThread->iTMSCallProxyLocal.SendToCallServer(
 
   804                 status = callThread->iTMSCallProxyLocal.SendToCallServer(
 
   738                         func, value);
 
   805                         func, value);
 
   739                 if (status != KErrNone)
 
   806                 if (status != TMS_RESULT_SUCCESS)
 
   740                     {
 
   807                     {
 
   741                     break;
 
   808                     break;
 
   742                     }
 
   809                     }
 
   743                 }
 
   810                 }
 
   744             }
 
   811             }
 
   745         i++;
 
   812         i++;
 
   746         }
 
   813         }
 
       
   814 
       
   815     TRACE_PRN_FN_EXT;
 
   747     return status;
 
   816     return status;
 
   748     }
 
   817     }
 
   749 
   818 
   750 // -----------------------------------------------------------------------------
 
   819 // -----------------------------------------------------------------------------
 
   751 // TMSServer::SendMessageToCallServ
 
   820 // TMSServer::SendMessageToCallServ
 
   752 //
 
   821 //
 
   753 // -----------------------------------------------------------------------------
 
   822 // -----------------------------------------------------------------------------
 
   754 //
 
   823 //
 
   755 TInt TMSServer::SendMessageToCallServ(TInt func, TIpcArgs args)
 
   824 TInt TMSServer::SendMessageToCallServ(TInt func, TIpcArgs args)
 
   756     {
 
   825     {
 
   757     TInt status(KErrNone);
 
   826     TRACE_PRN_FN_ENT;
 
       
   827 
       
   828     TInt status(TMS_RESULT_SUCCESS);
 
   758     TInt i = 0;
 
   829     TInt i = 0;
 
   759     while (i < iTMSCallServList.Count())
 
   830     while (i < iTMSCallServList.Count())
 
   760         {
 
   831         {
 
   761         CStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   832         TMSStartAndMonitorTMSCallThread* callThread = iTMSCallServList[i];
 
   762 
   833 
   763         if (callThread)
 
   834         if (callThread)
 
   764             {
 
   835             {
 
   765             if (!callThread->IsActive())
 
   836             if (!callThread->IsActive())
 
   766                 {
 
   837                 {
 
   769                 }
 
   840                 }
 
   770             else
 
   841             else
 
   771                 {
 
   842                 {
 
   772                 status = callThread->iTMSCallProxyLocal.SendToCallServer(
 
   843                 status = callThread->iTMSCallProxyLocal.SendToCallServer(
 
   773                         func, args);
 
   844                         func, args);
 
   774                 if (status != KErrNone)
 
   845                 if (status != TMS_RESULT_SUCCESS)
 
   775                     {
 
   846                     {
 
   776                     break;
 
   847                     break;
 
   777                     }
 
   848                     }
 
   778                 }
 
   849                 }
 
   779             }
 
   850             }
 
   780         i++;
 
   851         i++;
 
   781         }
 
   852         }
 
       
   853 
       
   854     TRACE_PRN_FN_EXT;
 
   782     return status;
 
   855     return status;
 
   783     }
 
   856     }
 
   784 
   857 
   785 // -----------------------------------------------------------------------------
 
   858 // -----------------------------------------------------------------------------
 
   786 // TMSServer::NotifyTarClients
 
   859 // TMSServer::NotifyTarClients
 
   787 //
 
   860 //
 
   788 // -----------------------------------------------------------------------------
 
   861 // -----------------------------------------------------------------------------
 
   789 //
 
   862 //
 
   790 TInt TMSServer::NotifyTarClients(TRoutingMsgBufPckg routingpckg)
 
   863 TInt TMSServer::NotifyTarClients(TRoutingMsgBufPckg routingpckg)
 
   791     {
 
   864     {
 
       
   865     TRACE_PRN_FN_ENT;
 
       
   866 
   792     iCurrentRouting = routingpckg().iOutput;
 
   867     iCurrentRouting = routingpckg().iOutput;
 
   793     iSessionIter.SetToFirst();
 
   868     iSessionIter.SetToFirst();
 
   794     TMSServerSession* serverSession =
 
   869     TMSServerSession* serverSession =
 
   795             static_cast<TMSServerSession*> (iSessionIter++);
 
   870             static_cast<TMSServerSession*> (iSessionIter++);
 
   796 
   871 
   797     while (serverSession != NULL)
 
   872     while (serverSession != NULL)
 
   798         {
 
   873         {
 
   799         serverSession->HandleRoutingChange(routingpckg);
 
   874         serverSession->HandleRoutingChange(routingpckg);
 
   800         serverSession = static_cast<TMSServerSession*> (iSessionIter++);
 
   875         serverSession = static_cast<TMSServerSession*> (iSessionIter++);
 
   801         }
 
   876         }
 
   802     return KErrNone;
 
   877 
       
   878     TRACE_PRN_FN_EXT;
 
       
   879     return TMS_RESULT_SUCCESS;
 
       
   880     }
 
       
   881 
       
   882 // -----------------------------------------------------------------------------
 
       
   883 // TMSServer::StartDTMF
 
       
   884 //
 
       
   885 // -----------------------------------------------------------------------------
 
       
   886 //
 
       
   887 TInt TMSServer::StartDTMF(const RMessage2& aMessage)
 
       
   888     {
 
       
   889     TRACE_PRN_FN_ENT;
 
       
   890 
       
   891     TInt status(TMS_RESULT_SUCCESS);
 
       
   892     TInt len(0);
 
       
   893     TMSStreamType strmtype;
 
       
   894 
       
   895     strmtype = (TMSStreamType) aMessage.Int0();
 
       
   896     len = aMessage.GetDesLength(1);
 
       
   897     HBufC* tone(NULL);
 
       
   898     if (len > 0)
 
       
   899         {
 
       
   900         delete tone;
 
       
   901         tone = NULL;
 
       
   902         TRAP(status,tone = HBufC::NewL(len));
 
       
   903         if (status == TMS_RESULT_SUCCESS)
 
       
   904             {
 
       
   905             TPtr ptr = tone->Des();
 
       
   906             status = aMessage.Read(1, ptr);
 
       
   907             TRACE_PRN_N(ptr);
 
       
   908 
       
   909             TIpcArgs args;
 
       
   910             args.Set(0, strmtype);
 
       
   911             args.Set(1, &ptr);
 
       
   912             status = SendMessageToCallServ(TMS_DTMF_START, args);
 
       
   913             delete tone;
 
       
   914             tone = NULL;
 
       
   915             }
 
       
   916         }
 
       
   917     aMessage.Complete(status);
 
       
   918 
       
   919     TRACE_PRN_FN_EXT;
 
       
   920     return status;
 
       
   921     }
 
       
   922 
       
   923 // -----------------------------------------------------------------------------
 
       
   924 // TMSServer::StopDTMF
 
       
   925 //
 
       
   926 // -----------------------------------------------------------------------------
 
       
   927 //
 
       
   928 TInt TMSServer::StopDTMF(const RMessage2& aMessage)
 
       
   929     {
 
       
   930     TRACE_PRN_FN_ENT;
 
       
   931 
       
   932     TInt status(TMS_RESULT_SUCCESS);
 
       
   933     TMSStreamType streamtype;
 
       
   934     streamtype = (TMSStreamType) aMessage.Int0();
 
       
   935     status = SendMessageToCallServ(TMS_DTMF_STOP, streamtype);
 
       
   936     aMessage.Complete(status);
 
       
   937 
       
   938     TRACE_PRN_FN_EXT;
 
       
   939     return status;
 
       
   940     }
 
       
   941 
       
   942 // -----------------------------------------------------------------------------
 
       
   943 // TMSServer::ContinueSendingDTMF
 
       
   944 //
 
       
   945 // -----------------------------------------------------------------------------
 
       
   946 //
 
       
   947 TInt TMSServer::ContinueSendingDTMF(const RMessage2& aMessage)
 
       
   948     {
 
       
   949     TRACE_PRN_FN_ENT;
 
       
   950 
       
   951     TInt status(TMS_RESULT_SUCCESS);
 
       
   952     TBool continuesending;
 
       
   953     continuesending = (TBool) aMessage.Int0();
 
       
   954     status = SendMessageToCallServ(TMS_DTMF_CONTINUE, continuesending);
 
       
   955     aMessage.Complete(status);
 
       
   956 
       
   957     TRACE_PRN_FN_EXT;
 
       
   958     return status;
 
       
   959     }
 
       
   960 
       
   961 // -----------------------------------------------------------------------------
 
       
   962 // TMSServer::NotifyDtmfClients
 
       
   963 //
 
       
   964 // -----------------------------------------------------------------------------
 
       
   965 //
 
       
   966 TInt TMSServer::NotifyDtmfClients(TmsMsgBufPckg dtmfpckg)
 
       
   967     {
 
       
   968     TRACE_PRN_FN_ENT;
 
       
   969 
       
   970     iSessionIter.SetToFirst();
 
       
   971     TMSServerSession* serverSession =
 
       
   972             static_cast<TMSServerSession*> (iSessionIter++);
 
       
   973 
       
   974     while (serverSession != NULL)
 
       
   975         {
 
       
   976         serverSession->NotifyClient(dtmfpckg().iRequest, dtmfpckg().iStatus);
 
       
   977         serverSession = static_cast<TMSServerSession*> (iSessionIter++);
 
       
   978         }
 
       
   979 
       
   980     TRACE_PRN_FN_EXT;
 
       
   981     return TMS_RESULT_SUCCESS;
 
       
   982     }
 
       
   983 
       
   984 // -----------------------------------------------------------------------------
 
       
   985 // TMSServer::InitRingTonePlayerL
 
       
   986 //
 
       
   987 // -----------------------------------------------------------------------------
 
       
   988 //
 
       
   989 void TMSServer::InitRingTonePlayerL()
 
       
   990     {
 
       
   991     TRACE_PRN_FN_ENT;
 
       
   992 
       
   993     DeinitRingTonePlayer();
 
       
   994 
       
   995     if (!iTMSRtPlayer)
 
       
   996         {
 
       
   997         iTMSRtPlayer = TMSRingTonePlayer::NewL(*this);
 
       
   998         }
 
       
   999 
       
  1000     TRACE_PRN_FN_EXT;
 
       
  1001     }
 
       
  1002 
       
  1003 // -----------------------------------------------------------------------------
 
       
  1004 // TMSServer::DeinitRingTonePlayer
 
       
  1005 //
 
       
  1006 // -----------------------------------------------------------------------------
 
       
  1007 //
 
       
  1008 void TMSServer::DeinitRingTonePlayer()
 
       
  1009     {
 
       
  1010     TRACE_PRN_FN_ENT;
 
       
  1011 
       
  1012     if (iTMSRtPlayer)
 
       
  1013         {
 
       
  1014         iTMSRtPlayer->DeinitRingTonePlayer();
 
       
  1015         }
 
       
  1016 
       
  1017     delete iRtFile;
 
       
  1018     iRtFile = NULL;
 
       
  1019     delete iRtSequence;
 
       
  1020     iRtSequence = NULL;
 
       
  1021     delete iTtsText;
 
       
  1022     iTtsText = NULL;
 
       
  1023 
       
  1024     TRACE_PRN_FN_EXT;
 
       
  1025     }
 
       
  1026 
       
  1027 // -----------------------------------------------------------------------------
 
       
  1028 // TMSServer::OpenRingTonePlayerFromFileL
 
       
  1029 //
 
       
  1030 // -----------------------------------------------------------------------------
 
       
  1031 //
 
       
  1032 void TMSServer::OpenRingTonePlayerFromFileL(const RMessage2& aMessage)
 
       
  1033     {
 
       
  1034     TRACE_PRN_FN_ENT;
 
       
  1035 
       
  1036     gint status(TMS_RESULT_INVALID_ARGUMENT);
 
       
  1037     gint len = aMessage.GetDesLength(0);
 
       
  1038     if (len > 0)
 
       
  1039         {
 
       
  1040         InitRingTonePlayerL();
 
       
  1041 
       
  1042         if (iTMSRtPlayer)
 
       
  1043             {
 
       
  1044             iRtFile = HBufC::NewL(len);
 
       
  1045             TPtr ptr = iRtFile->Des();
 
       
  1046             aMessage.ReadL(0, ptr);
 
       
  1047             iTMSRtPlayer->CreateRingTonePlayerL(EPlayerAudio, *iRtFile);
 
       
  1048             len = aMessage.GetDesLength(1);
 
       
  1049             if (len > 0)
 
       
  1050                 {
 
       
  1051                 delete iTtsText;
 
       
  1052                 iTtsText = NULL;
 
       
  1053                 iTtsText = HBufC::NewL(len);
 
       
  1054                 TPtr ptr1 = iTtsText->Des();
 
       
  1055                 aMessage.ReadL(1, ptr1);
 
       
  1056                 iTMSRtPlayer->CreateTTSPlayerL(ptr1);
 
       
  1057                 }
 
       
  1058             status = TMS_RESULT_SUCCESS;
 
       
  1059             }
 
       
  1060         }
 
       
  1061     aMessage.Complete(status);
 
       
  1062 
       
  1063     TRACE_PRN_FN_EXT;
 
       
  1064     }
 
       
  1065 
       
  1066 // -----------------------------------------------------------------------------
 
       
  1067 // TMSServer::OpenRingTonePlayerFromProfileL
 
       
  1068 //
 
       
  1069 // -----------------------------------------------------------------------------
 
       
  1070 //
 
       
  1071 void TMSServer::OpenRingTonePlayerFromProfileL(const RMessage2& aMessage)
 
       
  1072     {
 
       
  1073     TRACE_PRN_FN_ENT;
 
       
  1074 
       
  1075     gint status(TMS_RESULT_INVALID_ARGUMENT);
 
       
  1076     InitRingTonePlayerL();
 
       
  1077 
       
  1078     if (iTMSRtPlayer)
 
       
  1079         {
 
       
  1080         iTMSRtPlayer->CreateRingTonePlayerL(EPlayerDefault);
 
       
  1081         gint len = aMessage.GetDesLength(1);
 
       
  1082         if (len > 0)
 
       
  1083             {
 
       
  1084             delete iTtsText;
 
       
  1085             iTtsText = NULL;
 
       
  1086             iTtsText = HBufC::NewL(len);
 
       
  1087             TPtr ptr = iTtsText->Des();
 
       
  1088             aMessage.ReadL(1, ptr);
 
       
  1089             iTMSRtPlayer->CreateTTSPlayerL(ptr);
 
       
  1090             }
 
       
  1091         status = TMS_RESULT_SUCCESS;
 
       
  1092         }
 
       
  1093     aMessage.Complete(status);
 
       
  1094 
       
  1095     TRACE_PRN_FN_EXT;
 
       
  1096     }
 
       
  1097 
       
  1098 // -----------------------------------------------------------------------------
 
       
  1099 // TMSServer::OpenRingToneSequencePlayerL
 
       
  1100 //
 
       
  1101 // -----------------------------------------------------------------------------
 
       
  1102 //
 
       
  1103 void TMSServer::OpenRingToneSequencePlayerL(const RMessage2& aMessage)
 
       
  1104     {
 
       
  1105     TRACE_PRN_FN_ENT;
 
       
  1106 
       
  1107     gint status(TMS_RESULT_INVALID_ARGUMENT);
 
       
  1108     gint len = aMessage.GetDesLength(0);
 
       
  1109     if (len > 0)
 
       
  1110         {
 
       
  1111         InitRingTonePlayerL();
 
       
  1112         iRtSequence = HBufC8::NewL(len);
 
       
  1113         TPtr8 ptr = iRtSequence->Des();
 
       
  1114         aMessage.ReadL(0, ptr);
 
       
  1115 
       
  1116         if (iTMSRtPlayer)
 
       
  1117             {
 
       
  1118             iTMSRtPlayer->CreateCustomSequencePlayerL(ptr);
 
       
  1119             status = TMS_RESULT_SUCCESS;
 
       
  1120             }
 
       
  1121         }
 
       
  1122     aMessage.Complete(status);
 
       
  1123 
       
  1124     TRACE_PRN_FN_EXT;
 
       
  1125     }
 
       
  1126 
       
  1127 // -----------------------------------------------------------------------------
 
       
  1128 // TMSServer::OpenRingToneBeepOnceL
 
       
  1129 //
 
       
  1130 // -----------------------------------------------------------------------------
 
       
  1131 //
 
       
  1132 void TMSServer::OpenRingToneBeepOnceL()
 
       
  1133     {
 
       
  1134     TRACE_PRN_FN_ENT;
 
       
  1135 
       
  1136     InitRingTonePlayerL();
 
       
  1137 
       
  1138     if (iTMSRtPlayer)
 
       
  1139         {
 
       
  1140         iTMSRtPlayer->CreateSequencePlayerL(EPlayerBeepOnce);
 
       
  1141         }
 
       
  1142 
       
  1143     TRACE_PRN_FN_EXT;
 
       
  1144     }
 
       
  1145 
       
  1146 // -----------------------------------------------------------------------------
 
       
  1147 // TMSServer::DeinitRingTone
 
       
  1148 //
 
       
  1149 // -----------------------------------------------------------------------------
 
       
  1150 //
 
       
  1151 void TMSServer::OpenRingToneSilentL()
 
       
  1152     {
 
       
  1153     TRACE_PRN_FN_ENT;
 
       
  1154 
       
  1155     InitRingTonePlayerL();
 
       
  1156 
       
  1157     if (iTMSRtPlayer)
 
       
  1158         {
 
       
  1159         iTMSRtPlayer->CreateSequencePlayerL(EPlayerSilent);
 
       
  1160         }
 
       
  1161 
       
  1162     TRACE_PRN_FN_EXT;
 
       
  1163     }
 
       
  1164 
       
  1165 // -----------------------------------------------------------------------------
 
       
  1166 // TMSServer::OpenRingToneUnsecureVoipL
 
       
  1167 //
 
       
  1168 // -----------------------------------------------------------------------------
 
       
  1169 //
 
       
  1170 void TMSServer::OpenRingToneUnsecureVoipL()
 
       
  1171     {
 
       
  1172     TRACE_PRN_FN_ENT;
 
       
  1173 
       
  1174     InitRingTonePlayerL();
 
       
  1175 
       
  1176     if (iTMSRtPlayer)
 
       
  1177         {
 
       
  1178         iTMSRtPlayer->CreateSequencePlayerL(EPlayerUnsecureVoIP);
 
       
  1179         }
 
       
  1180 
       
  1181     TRACE_PRN_FN_EXT;
 
       
  1182     }
 
       
  1183 
       
  1184 // -----------------------------------------------------------------------------
 
       
  1185 // TMSServer::PlayRingToneL
 
       
  1186 //
 
       
  1187 // -----------------------------------------------------------------------------
 
       
  1188 //
 
       
  1189 void TMSServer::PlayRingToneL()
 
       
  1190     {
 
       
  1191     TRACE_PRN_FN_ENT;
 
       
  1192 
       
  1193     if (iTMSRtPlayer)
 
       
  1194         {
 
       
  1195         iTMSRtPlayer->PlayRingToneL();
 
       
  1196         }
 
       
  1197     else
 
       
  1198         {
 
       
  1199         User::Leave(TMS_RESULT_UNINITIALIZED_OBJECT);
 
       
  1200         }
 
       
  1201 
       
  1202     TRACE_PRN_FN_EXT;
 
       
  1203     }
 
       
  1204 
       
  1205 // -----------------------------------------------------------------------------
 
       
  1206 // TMSServer::PauseVideoRingTone
 
       
  1207 //
 
       
  1208 // -----------------------------------------------------------------------------
 
       
  1209 //
 
       
  1210 void TMSServer::PauseVideoRingTone()
 
       
  1211     {
 
       
  1212     StopRingTone();
 
       
  1213     }
 
       
  1214 
       
  1215 // -----------------------------------------------------------------------------
 
       
  1216 // TMSServer::StopRingTone
 
       
  1217 //
 
       
  1218 // -----------------------------------------------------------------------------
 
       
  1219 //
 
       
  1220 void TMSServer::StopRingTone()
 
       
  1221     {
 
       
  1222     TRACE_PRN_FN_ENT;
 
       
  1223 
       
  1224     if (iTMSRtPlayer)
 
       
  1225         {
 
       
  1226         iTMSRtPlayer->StopPlaying();
 
       
  1227         }
 
       
  1228 
       
  1229     TRACE_PRN_FN_EXT;
 
       
  1230     }
 
       
  1231 
       
  1232 // -----------------------------------------------------------------------------
 
       
  1233 // TMSServer::MuteRingTone
 
       
  1234 //
 
       
  1235 // -----------------------------------------------------------------------------
 
       
  1236 //
 
       
  1237 void TMSServer::MuteRingTone()
 
       
  1238     {
 
       
  1239     TRACE_PRN_FN_ENT;
 
       
  1240 
       
  1241     if (iTMSRtPlayer)
 
       
  1242         {
 
       
  1243         iTMSRtPlayer->MuteRingTone();
 
       
  1244         }
 
       
  1245 
       
  1246     TRACE_PRN_FN_EXT;
 
       
  1247     }
 
       
  1248 
       
  1249 // -----------------------------------------------------------------------------
 
       
  1250 // TMSServer::RtPlayerEvent
 
       
  1251 //
 
       
  1252 // -----------------------------------------------------------------------------
 
       
  1253 //
 
       
  1254 void TMSServer::RtPlayerEvent(gint aEventType, gint aError)
 
       
  1255     {
 
       
  1256     TRACE_PRN_FN_ENT;
 
       
  1257 
       
  1258     iSessionIter.SetToFirst();
 
       
  1259     TMSServerSession* ss = static_cast<TMSServerSession*> (iSessionIter++);
 
       
  1260 
       
  1261     while (ss != NULL)
 
       
  1262         {
 
       
  1263         ss->NotifyClient(aEventType, aError);
 
       
  1264         ss = static_cast<TMSServerSession*> (iSessionIter++);
 
       
  1265         }
 
       
  1266 
       
  1267     TRACE_PRN_FN_EXT;
 
   803     }
 
  1268     }
 
   804 
  1269 
   805 // -----------------------------------------------------------------------------
 
  1270 // -----------------------------------------------------------------------------
 
   806 // RunServerL
 
  1271 // RunServerL
 
   807 //
 
  1272 //
 
   818 
  1283 
   819     // Create the server (leave it on the cleanup stack)
 
  1284     // Create the server (leave it on the cleanup stack)
 
   820     TMSServer* server = TMSServer::NewL();
 
  1285     TMSServer* server = TMSServer::NewL();
 
   821 
  1286 
   822     // Initialisation complete, now signal the client
 
  1287     // Initialisation complete, now signal the client
 
   823     RProcess::Rendezvous(KErrNone);
 
  1288     RProcess::Rendezvous(TMS_RESULT_SUCCESS);
 
   824 
  1289 
   825     // Start the scheduler and wait for client requests
 
  1290     // Start the scheduler and wait for client requests
 
   826     CActiveScheduler::Start();
 
  1291     CActiveScheduler::Start();
 
   827 
  1292 
   828     // Ready to exit.
 
  1293     // Ready to exit.
 
   832 
  1297 
   833     TRACE_PRN_N(_L("TMS->RunServerL - TMS server closed"));
 
  1298     TRACE_PRN_N(_L("TMS->RunServerL - TMS server closed"));
 
   834     }
 
  1299     }
 
   835 
  1300 
   836 // -----------------------------------------------------------------------------
 
  1301 // -----------------------------------------------------------------------------
 
   837 // CStartAndMonitorTMSCallThread::CStartAndMonitorTMSCallThread
 
  1302 // TMSStartAndMonitorTMSCallThread::TMSStartAndMonitorTMSCallThread
 
   838 // Perhaps we need to move this to a .cpp?
 
  1303 // Perhaps we need to move this to a .cpp?
 
   839 // -----------------------------------------------------------------------------
 
  1304 // -----------------------------------------------------------------------------
 
   840 //
 
  1305 //
 
   841 CStartAndMonitorTMSCallThread::CStartAndMonitorTMSCallThread(
 
  1306 TMSStartAndMonitorTMSCallThread::TMSStartAndMonitorTMSCallThread(
 
   842         TMSServer* aServer) :
 
  1307         TMSServer* aServer) :
 
   843     CActive(EPriorityStandard),
 
  1308     CActive(EPriorityStandard),
 
   844     iTMSServer(aServer)
 
  1309     iTMSServer(aServer)
 
   845     {
 
  1310     {
 
   846     TRACE_PRN_FN_ENT;
 
  1311     TRACE_PRN_FN_ENT;
 
   847     CActiveScheduler::Add(this);
 
  1312     CActiveScheduler::Add(this);
 
   848     TRACE_PRN_FN_EXT;
 
  1313     TRACE_PRN_FN_EXT;
 
   849     }
 
  1314     }
 
   850 
  1315 
   851 // -----------------------------------------------------------------------------
 
  1316 // -----------------------------------------------------------------------------
 
   852 // CStartAndMonitorTMSCallThread::~CStartAndMonitorTMSCallThread
 
  1317 // TMSStartAndMonitorTMSCallThread::~TMSStartAndMonitorTMSCallThread
 
   853 //
 
  1318 //
 
   854 // -----------------------------------------------------------------------------
 
  1319 // -----------------------------------------------------------------------------
 
   855 //
 
  1320 //
 
   856 CStartAndMonitorTMSCallThread::~CStartAndMonitorTMSCallThread()
 
  1321 TMSStartAndMonitorTMSCallThread::~TMSStartAndMonitorTMSCallThread()
 
   857     {
 
  1322     {
 
   858     TRACE_PRN_FN_ENT;
 
  1323     TRACE_PRN_FN_ENT;
 
   859     Cancel();
 
  1324     Cancel();
 
   860     TRACE_PRN_FN_EXT;
 
  1325     TRACE_PRN_FN_EXT;
 
   861     }
 
  1326     }
 
   862 
  1327 
   863 // -----------------------------------------------------------------------------
 
  1328 // -----------------------------------------------------------------------------
 
   864 // CStartAndMonitorTMSCallThread::NewL
 
  1329 // TMSStartAndMonitorTMSCallThread::NewL
 
   865 //
 
  1330 //
 
   866 // -----------------------------------------------------------------------------
 
  1331 // -----------------------------------------------------------------------------
 
   867 //
 
  1332 //
 
   868 CStartAndMonitorTMSCallThread* CStartAndMonitorTMSCallThread::NewL(
 
  1333 TMSStartAndMonitorTMSCallThread* TMSStartAndMonitorTMSCallThread::NewL(
 
   869         TMSServer* aServer)
 
  1334         TMSServer* aServer)
 
   870     {
 
  1335     {
 
   871     TRACE_PRN_FN_ENT;
 
  1336     TRACE_PRN_FN_ENT;
 
   872     CStartAndMonitorTMSCallThread* self =
 
  1337 
   873             new (ELeave) CStartAndMonitorTMSCallThread(aServer);
 
  1338     TMSStartAndMonitorTMSCallThread* self =
 
       
  1339             new (ELeave) TMSStartAndMonitorTMSCallThread(aServer);
 
   874     CleanupStack::PushL(self);
 
  1340     CleanupStack::PushL(self);
 
   875     self->ConstructL();
 
  1341     self->ConstructL();
 
   876     CleanupStack::Pop(self);
 
  1342     CleanupStack::Pop(self);
 
       
  1343 
   877     TRACE_PRN_FN_EXT;
 
  1344     TRACE_PRN_FN_EXT;
 
   878     return self;
 
  1345     return self;
 
   879     }
 
  1346     }
 
   880 
  1347 
   881 // -----------------------------------------------------------------------------
 
  1348 // -----------------------------------------------------------------------------
 
   882 // CStartAndMonitorTMSCallThread::ConstructL
 
  1349 // TMSStartAndMonitorTMSCallThread::ConstructL
 
   883 //
 
  1350 //
 
   884 // -----------------------------------------------------------------------------
 
  1351 // -----------------------------------------------------------------------------
 
   885 //
 
  1352 //
 
   886 void CStartAndMonitorTMSCallThread::ConstructL()
 
  1353 void TMSStartAndMonitorTMSCallThread::ConstructL()
 
   887     {
 
  1354     {
 
   888     TRACE_PRN_FN_ENT;
 
  1355     TRACE_PRN_FN_ENT;
 
   889     TRACE_PRN_FN_EXT;
 
  1356     TRACE_PRN_FN_EXT;
 
   890     }
 
  1357     }
 
   891 
  1358 
   892 // -----------------------------------------------------------------------------
 
  1359 // -----------------------------------------------------------------------------
 
   893 // CStartAndMonitorTMSCallThread::StartTMSCallServer
 
  1360 // TMSStartAndMonitorTMSCallThread::StartTMSCallServer
 
   894 //
 
  1361 //
 
   895 // -----------------------------------------------------------------------------
 
  1362 // -----------------------------------------------------------------------------
 
   896 //
 
  1363 //
 
   897 TInt CStartAndMonitorTMSCallThread::StartTMSCallServer(TMSCallProxyLocal& aHndl)
 
  1364 TInt TMSStartAndMonitorTMSCallThread::StartTMSCallServer(
 
   898     {
 
  1365         TMSCallProxyLocal& aHndl)
 
   899     TRACE_PRN_FN_ENT;
 
  1366     {
 
   900 
  1367     TRACE_PRN_FN_ENT;
 
   901     TInt status(KErrNone);
 
  1368 
       
  1369     TInt status(TMS_RESULT_SUCCESS);
 
   902     TMSCallServerStartParam start(iTMSServer, iCallSrvrHndl);
 
  1370     TMSCallServerStartParam start(iTMSServer, iCallSrvrHndl);
 
   903     const TUidType serverUid(KNullUid, KNullUid, KUidTMSCallServerUid3);
 
  1371     const TUidType serverUid(KNullUid, KNullUid, KUidTMSCallServerUid3);
 
   904     TThreadFunction serverFunc = TMSCallServer::StartThread;
 
  1372     TThreadFunction serverFunc = TMSCallServer::StartThread;
 
   905 
  1373 
   906     status = iServerThread.Create(_L(""),
 
  1374     status = iServerThread.Create(_L(""),
 
   909                                   KTMSCallServerInitHeapSize,
 
  1377                                   KTMSCallServerInitHeapSize,
 
   910                                   KTMSCallServerMaxHeapSize,
 
  1378                                   KTMSCallServerMaxHeapSize,
 
   911                                   &start,
 
  1379                                   &start,
 
   912                                   EOwnerProcess);
 
  1380                                   EOwnerProcess);
 
   913 
  1381 
   914     if (status != KErrNone)
 
  1382     if (status != TMS_RESULT_SUCCESS)
 
   915         {
 
  1383         {
 
   916         return status;
 
  1384         return status;
 
   917         }
 
  1385         }
 
   918 
  1386 
   919     //NOTE: set priority to EPriorityRealTime or speech codec audio will choke.
 
  1387     //NOTE: set priority to EPriorityRealTime or speech codec audio will choke.
 
   933         iServerThread.Resume();
 
  1401         iServerThread.Resume();
 
   934         // Server will call the reciprocal static synchronise call
 
  1402         // Server will call the reciprocal static synchronise call
 
   935         }
 
  1403         }
 
   936 
  1404 
   937     User::WaitForRequest(reqStatus); // wait for start or death
 
  1405     User::WaitForRequest(reqStatus); // wait for start or death
 
   938     if (reqStatus.Int() != KErrNone)
 
  1406     if (reqStatus.Int() != TMS_RESULT_SUCCESS)
 
   939         {
 
  1407         {
 
   940         iServerThread.Close();
 
  1408         iServerThread.Close();
 
   941         iCallSrvrHndl.Close();
 
  1409         iCallSrvrHndl.Close();
 
   942         return reqStatus.Int();
 
  1410         return reqStatus.Int();
 
   943         }
 
  1411         }
 
   944     status = aHndl.Open(iCallSrvrHndl);
 
  1412     status = aHndl.Open(iCallSrvrHndl);
 
   945 
  1413 
   946     if (status != KErrNone)
 
  1414     if (status != TMS_RESULT_SUCCESS)
 
   947         {
 
  1415         {
 
   948         iServerThread.Close();
 
  1416         iServerThread.Close();
 
   949         iCallSrvrHndl.Close();
 
  1417         iCallSrvrHndl.Close();
 
   950         return status;
 
  1418         return status;
 
   951         }
 
  1419         }
 
   952     aHndl.ShareProtected();
 
  1420     aHndl.ShareProtected();
 
       
  1421     iStatus = KRequestPending;
 
   953     iServerThread.Logon(iStatus);
 
  1422     iServerThread.Logon(iStatus);
 
   954     SetActive();
 
  1423     SetActive();
 
   955 
  1424 
   956     TRACE_PRN_FN_EXT;
 
  1425     TRACE_PRN_FN_EXT;
 
   957     return KErrNone;
 
  1426     return TMS_RESULT_SUCCESS;
 
   958     }
 
  1427     }
 
   959 
  1428 
   960 // -----------------------------------------------------------------------------
 
  1429 // -----------------------------------------------------------------------------
 
   961 // CStartAndMonitorTMSCallThread::RunL
 
  1430 // TMSStartAndMonitorTMSCallThread::RunL
 
   962 // From CActive
 
  1431 // From CActive
 
   963 // -----------------------------------------------------------------------------
 
  1432 // -----------------------------------------------------------------------------
 
   964 //
 
  1433 //
 
   965 void CStartAndMonitorTMSCallThread::RunL()
 
  1434 void TMSStartAndMonitorTMSCallThread::RunL()
 
   966     {
 
  1435     {
 
   967     TRACE_PRN_FN_ENT;
 
  1436     TRACE_PRN_FN_ENT;
 
   968     iServerThread.Close();
 
  1437     iServerThread.Close();
 
   969     //NOTE: This is causing a panic when closing down tms server.
 
  1438     //NOTE: This is causing a panic when closing down TMS server.
 
   970     //iCallSrvrHndl.Close();
 
  1439     //iCallSrvrHndl.Close();
 
   971     TRACE_PRN_FN_EXT;
 
  1440     TRACE_PRN_FN_EXT;
 
   972     }
 
  1441     }
 
   973 
  1442 
   974 // -----------------------------------------------------------------------------
 
  1443 // -----------------------------------------------------------------------------
 
   975 // CStartAndMonitorTMSCallThread::DoCancel
 
  1444 // TMSStartAndMonitorTMSCallThread::DoCancel
 
   976 // From CActive
 
  1445 // From CActive
 
   977 // -----------------------------------------------------------------------------
 
  1446 // -----------------------------------------------------------------------------
 
   978 //
 
  1447 //
 
   979 void CStartAndMonitorTMSCallThread::DoCancel()
 
  1448 void TMSStartAndMonitorTMSCallThread::DoCancel()
 
   980     {
 
  1449     {
 
   981     TRACE_PRN_FN_ENT;
 
  1450     TRACE_PRN_FN_ENT;
 
   982     iServerThread.LogonCancel(iStatus);
 
  1451     if (iServerThread.Handle())
 
       
  1452         {
 
       
  1453         iServerThread.LogonCancel(iStatus);
 
       
  1454         User::WaitForRequest(iStatus);
 
       
  1455         }
 
   983     TRACE_PRN_FN_EXT;
 
  1456     TRACE_PRN_FN_EXT;
 
   984     }
 
  1457     }
 
   985 
  1458 
   986 // -----------------------------------------------------------------------------
 
  1459 // -----------------------------------------------------------------------------
 
   987 // TMSCallProxyLocal::Open
 
  1460 // TMSCallProxyLocal::Open
 
   988 // Perhaps we need to move this to a .cpp?
 
  1461 // Perhaps we need to move this to a .cpp?
 
   989 // -----------------------------------------------------------------------------
 
  1462 // -----------------------------------------------------------------------------
 
   990 TInt TMSCallProxyLocal::Open(RServer2& aTMSCallServerHandle)
 
  1463 TInt TMSCallProxyLocal::Open(RServer2& aTMSCallServerHandle)
 
   991     {
 
  1464     {
 
   992     TRACE_PRN_FN_ENT;
 
  1465     TRACE_PRN_FN_ENT;
 
       
  1466 
   993     TInt status(KErrNotSupported);
 
  1467     TInt status(KErrNotSupported);
 
   994     status = CreateSession(aTMSCallServerHandle,
 
  1468     status = CreateSession(aTMSCallServerHandle,
 
   995                            TVersion(KTMSCallServerMajorVersionNumber,
 
  1469                            TVersion(KTMSCallServerMajorVersionNumber,
 
   996                                     KTMSCallServerMinorVersionNumber,
 
  1470                                     KTMSCallServerMinorVersionNumber,
 
   997                                     KTMSCallServerBuildVersionNumber),
 
  1471                                     KTMSCallServerBuildVersionNumber),
 
  1006 //
 
  1480 //
 
  1007 // -----------------------------------------------------------------------------
 
  1481 // -----------------------------------------------------------------------------
 
  1008 //
 
  1482 //
 
  1009 TInt TMSCallProxyLocal::SendToCallServer(TInt aFunc, TUint value)
 
  1483 TInt TMSCallProxyLocal::SendToCallServer(TInt aFunc, TUint value)
 
  1010     {
 
  1484     {
 
  1011     TInt status(KErrNone);
 
  1485     TInt status(TMS_RESULT_SUCCESS);
 
  1012     status = SendReceive(aFunc, TIpcArgs(value));
 
  1486     status = SendReceive(aFunc, TIpcArgs(value));
 
  1013     return status;
 
  1487     return status;
 
  1014     }
 
  1488     }
 
  1015 
  1489 
  1016 // -----------------------------------------------------------------------------
 
  1490 // -----------------------------------------------------------------------------
 
  1018 //
 
  1492 //
 
  1019 // -----------------------------------------------------------------------------
 
  1493 // -----------------------------------------------------------------------------
 
  1020 //
 
  1494 //
 
  1021 TInt TMSCallProxyLocal::SendToCallServer(TInt aFunc, TIpcArgs args)
 
  1495 TInt TMSCallProxyLocal::SendToCallServer(TInt aFunc, TIpcArgs args)
 
  1022     {
 
  1496     {
 
  1023     TInt status(KErrNone);
 
  1497     TInt status(TMS_RESULT_SUCCESS);
 
  1024     status = SendReceive(aFunc, args);
 
  1498     status = SendReceive(aFunc, args);
 
  1025     return status;
 
  1499     return status;
 
  1026     }
 
  1500     }
 
  1027 
  1501 
  1028 // -----------------------------------------------------------------------------
 
  1502 // -----------------------------------------------------------------------------
 
  1030 //
 
  1504 //
 
  1031 // -----------------------------------------------------------------------------
 
  1505 // -----------------------------------------------------------------------------
 
  1032 //
 
  1506 //
 
  1033 TInt TMSCallProxyLocal::ReceiveFromCallServer(TInt aFunc, TUint& value)
 
  1507 TInt TMSCallProxyLocal::ReceiveFromCallServer(TInt aFunc, TUint& value)
 
  1034     {
 
  1508     {
 
  1035     TInt status(KErrNone);
 
  1509     TInt status(TMS_RESULT_SUCCESS);
 
  1036     TPckgBuf<TUint> pckg;
 
  1510     TPckgBuf<TUint> pckg;
 
  1037     TIpcArgs args(&pckg);
 
  1511     TIpcArgs args(&pckg);
 
  1038     status = SendReceive(aFunc, args);
 
  1512     status = SendReceive(aFunc, args);
 
  1039     if (status == KErrNone)
 
  1513     if (status == TMS_RESULT_SUCCESS)
 
  1040         {
 
  1514         {
 
  1041         value = pckg();
 
  1515         value = pckg();
 
  1042         }
 
  1516         }
 
  1043     return status;
 
  1517     return status;
 
  1044     }
 
  1518     }
 
  1048 //
 
  1522 //
 
  1049 // -----------------------------------------------------------------------------
 
  1523 // -----------------------------------------------------------------------------
 
  1050 //
 
  1524 //
 
  1051 TInt TMSCallProxyLocal::ReceiveFromCallServer(TInt aFunc, TIpcArgs args)
 
  1525 TInt TMSCallProxyLocal::ReceiveFromCallServer(TInt aFunc, TIpcArgs args)
 
  1052     {
 
  1526     {
 
  1053     TInt status(KErrNone);
 
  1527     TInt status(TMS_RESULT_SUCCESS);
 
  1054     status = SendReceive(aFunc, args);
 
  1528     status = SendReceive(aFunc, args);
 
  1055     return status;
 
  1529     return status;
 
  1056     }
 
  1530     }
 
  1057 
  1531 
  1058 // -----------------------------------------------------------------------------
 
  1532 // -----------------------------------------------------------------------------
FCL/sf/mw/mmmw