mmserv/tms/tmsproxy/src/tmsproxy.cpp
changeset 42 1fa3fb47b1e3
parent 22 128eb6a32b84
child 55 e267340986c9
equal deleted inserted replaced
32:94fc26b6e006 42:1fa3fb47b1e3
    28 #include "tmsproxy.h"
    28 #include "tmsproxy.h"
    29 
    29 
    30 using namespace TMS;
    30 using namespace TMS;
    31 
    31 
    32 // CONSTANTS
    32 // CONSTANTS
    33 const TUint KTMSServerConnectRetries = 2;
    33 const guint KTMSServerConnectRetries = 2;
    34 const TUint KSessionMessageSlots = 10;
    34 const guint KSessionMessageSlots = 10;
    35 const TUint KUTF8Multiply = 2;
    35 const guint KUTF8Multiply = 2;
    36 
    36 
    37 // -----------------------------------------------------------------------------
    37 // -----------------------------------------------------------------------------
    38 // StartServer
    38 // TMSProxy::StartServer
    39 //
    39 //
    40 // Function that will launch TMS server executable in it its own process.
    40 // Function that will launch TMS server executable in it its own process.
    41 // Start the server process/thread, which lives in an EPOCEXE object.
    41 // Start the server process/thread, which lives in an EPOCEXE object.
    42 // Returns: gint: TMS_RESULT_SUCCESS (0) if no error.
    42 // Returns: gint: TMS_RESULT_SUCCESS (0) if no error.
    43 // -----------------------------------------------------------------------------
    43 // -----------------------------------------------------------------------------
   117 //
   117 //
   118 EXPORT_C gint TMSProxy::Connect()
   118 EXPORT_C gint TMSProxy::Connect()
   119     {
   119     {
   120     TRACE_PRN_FN_ENT;
   120     TRACE_PRN_FN_ENT;
   121 
   121 
   122     gint retry = KTMSServerConnectRetries;
   122     guint retry = KTMSServerConnectRetries;
   123     gint err(TMS_RESULT_GENERAL_ERROR);
   123     gint err(TMS_RESULT_GENERAL_ERROR);
   124     gint numMessageSlots = KSessionMessageSlots;
       
   125 
   124 
   126     for (;;)
   125     for (;;)
   127         {
   126         {
   128         // Try to create a new session with the server
   127         // Try to create a new session with the server
   129         err = CreateSession(KTMSServerName, Version(), numMessageSlots);
   128         err = CreateSession(KTMSServerName, Version(), KSessionMessageSlots);
   130 
   129 
   131         if ((err != KErrNotFound) && (err != KErrServerTerminated))
   130         if ((err != KErrNotFound) && (err != KErrServerTerminated))
   132             {
   131             {
   133             TRACE_PRN_N1(_L("[TMS session created; err==%d]"), err);
   132             TRACE_PRN_N1(_L("[TMS session created; err==%d]"), err);
   134             break; // Connected to existing server - ok
   133             break; // Connected to existing server - ok
   181     TRACE_PRN_FN_EXT;
   180     TRACE_PRN_FN_EXT;
   182     }
   181     }
   183 
   182 
   184 EXPORT_C gint TMSProxy::GetTMSCallSessionHandle()
   183 EXPORT_C gint TMSProxy::GetTMSCallSessionHandle()
   185     {
   184     {
   186     gint err(TMS_RESULT_SUCCESS);
   185     gint handle = SendReceive(ETMSCallSessionHandle);
   187     err = SendReceive(ETMSCallSessionHandle);
   186     return handle;
   188     return TMSRESULT(err);
       
   189     }
   187     }
   190 
   188 
   191 EXPORT_C gint TMSProxy::GetSupportedDecoders(RArray<TUint32>& aDecoders,
   189 EXPORT_C gint TMSProxy::GetSupportedDecoders(RArray<TUint32>& aDecoders,
   192         gint& aFrameSize)
   190         gint& aFrameSize)
   193     {
   191     {
   412 
   410 
   413     if (tts)
   411     if (tts)
   414         {
   412         {
   415         // Convert buffer from UTF-8 to unicode (16-bit)
   413         // Convert buffer from UTF-8 to unicode (16-bit)
   416         // Note: UTF-8 strings can take up to 4 bytes per character
   414         // Note: UTF-8 strings can take up to 4 bytes per character
   417         gint unilen = tts->len / KUTF8Multiply;
   415         guint unilen = tts->len / KUTF8Multiply;
   418         TRAP(status, ttsBuf = HBufC::NewL(unilen));
   416         TRAP(status, ttsBuf = HBufC::NewL(unilen));
   419         if (status == KErrNone)
   417         if (status == KErrNone)
   420             {
   418             {
   421             TPtr p = ttsBuf->Des();
   419             TPtr p = ttsBuf->Des();
   422             p.Copy((TUint16*) tts->str, unilen);
   420             p.Copy((TUint16*) tts->str, unilen);
   436             if (str)
   434             if (str)
   437                 {
   435                 {
   438                 HBufC* buf(NULL);
   436                 HBufC* buf(NULL);
   439                 // Convert buffer from UTF-8 to unicode (16-bit)
   437                 // Convert buffer from UTF-8 to unicode (16-bit)
   440                 // Note: UTF-8 strings can take up to 4 bytes per character
   438                 // Note: UTF-8 strings can take up to 4 bytes per character
   441                 gint unilen = str->len / KUTF8Multiply;
   439                 guint unilen = str->len / KUTF8Multiply;
   442 
   440 
   443                 TRAP(status, buf = HBufC::NewL(unilen));
   441                 TRAP(status, buf = HBufC::NewL(unilen));
   444                 if (buf && status == KErrNone)
   442                 if (buf && status == KErrNone)
   445                     {
   443                     {
   446                     TPtr p = buf->Des();
   444                     TPtr p = buf->Des();
   535     gint status(TMS_RESULT_SUCCESS);
   533     gint status(TMS_RESULT_SUCCESS);
   536     status = RSessionBase::SendReceive(ETMSRingToneMute);
   534     status = RSessionBase::SendReceive(ETMSRingToneMute);
   537     return TMSRESULT(status);
   535     return TMSRESULT(status);
   538     }
   536     }
   539 
   537 
       
   538 EXPORT_C gint TMSProxy::InitDTMFPlayer(TMSStreamType streamtype)
       
   539     {
       
   540     gint status(TMS_RESULT_SUCCESS);
       
   541     TIpcArgs args;
       
   542     args.Set(0, streamtype);
       
   543     status = RSessionBase::SendReceive(ETMSInitDTMF, args);
       
   544     return TMSRESULT(status);
       
   545     }
       
   546 
   540 EXPORT_C gint TMSProxy::StartDTMF(TMSStreamType streamtype, GString* tone)
   547 EXPORT_C gint TMSProxy::StartDTMF(TMSStreamType streamtype, GString* tone)
   541     {
   548     {
   542     TRACE_PRN_FN_ENT;
   549     TRACE_PRN_FN_ENT;
   543     __ASSERT_ALWAYS(tone, PANIC(TMS_RESULT_NULL_ARGUMENT));
   550     __ASSERT_ALWAYS(tone, PANIC(TMS_RESULT_NULL_ARGUMENT));
   544 
   551 
   597     {
   604     {
   598     TRACE_PRN_FN_ENT;
   605     TRACE_PRN_FN_ENT;
   599     gint status(TMS_RESULT_SUCCESS);
   606     gint status(TMS_RESULT_SUCCESS);
   600     status = RSessionBase::SendReceive(ETMSStopInbandTone);
   607     status = RSessionBase::SendReceive(ETMSStopInbandTone);
   601     TRACE_PRN_FN_EXT;
   608     TRACE_PRN_FN_EXT;
   602     return TMSRESULT(status);
       
   603     }
       
   604 
       
   605 EXPORT_C gint TMSProxy::StartDTMFNotifier()
       
   606     {
       
   607     gint status(TMS_RESULT_SUCCESS);
       
   608     status = RSessionBase::SendReceive(ETMSStartDTMFNotifier); //DTMFHandler
       
   609     return TMSRESULT(status);
       
   610     }
       
   611 
       
   612 EXPORT_C gint TMSProxy::CancelDTMFNotifier()
       
   613     {
       
   614     gint status(TMS_RESULT_SUCCESS);
       
   615     status = RSessionBase::SendReceive(ETMSCancelDTMFNotifier); //DTMFHandler
       
   616     return TMSRESULT(status);
   609     return TMSRESULT(status);
   617     }
   610     }
   618 
   611 
   619 EXPORT_C gint TMSProxy::StartGlobalEffectNotifier()
   612 EXPORT_C gint TMSProxy::StartGlobalEffectNotifier()
   620     {
   613     {