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/tmsproxy/src/tmsproxy.cpp
changeset 22 128eb6a32b84
parent 14 80975da52420
child 33 5e8b14bae8c3
child 42 1fa3fb47b1e3
equal deleted inserted replaced
16:43d09473c595 22:128eb6a32b84 
    34 const TUint KSessionMessageSlots = 10;
 
    34 const TUint KSessionMessageSlots = 10;
 
    35 const TUint KUTF8Multiply = 2;
 
    35 const TUint KUTF8Multiply = 2;
 
    36 
    36 
    37 // -----------------------------------------------------------------------------
 
    37 // -----------------------------------------------------------------------------
 
    38 // StartServer
 
    38 // StartServer
 
    39 // Static function to start the server process thread.
 
    39 //
 
    40 // Start the server process/thread which lives in an EPOCEXE object.
 
    40 // Function that will launch TMS server executable in it its own process.
 
    41 // Returns: gint: TMS_RESULT_SUCCESS (0) if no error
 
    41 // Start the server process/thread, which lives in an EPOCEXE object.
 
    42 // -----------------------------------------------------------------------------
 
    42 // Returns: gint: TMS_RESULT_SUCCESS (0) if no error.
 
    43 //
 
    43 // -----------------------------------------------------------------------------
 
    44 static gint StartServer()
 
    44 //
 
       
    45 gint TMSProxy::StartServer()
 
    45     {
 
    46     {
 
    46     const TUidType serverUid(KNullUid, KNullUid, KTMSServerUid3);
 
    47     const TUidType serverUid(KNullUid, KNullUid, KTMSServerUid3);
 
    47 
    48 
    48     // Only one instance of the server is allowed. Attempt of launching
 
    49     // Only one instance of the server is allowed. Attempt of launching
 
    49     // second instance of the server will fail with KErrAlreadyExists.
 
    50     // second instance of the server will fail with KErrAlreadyExists.
 
    50     RProcess server;
 
    51     RProcess server;
 
    51     gint r = server.Create(KTMSServerName, KNullDesC, serverUid);
 
    52     gint ret = server.Create(KTMSServerFile, KNullDesC, serverUid);
 
    52 
    53 
    53     if (r != TMS_RESULT_SUCCESS)
 
    54     if (ret == TMS_RESULT_SUCCESS)
 
    54         {
 
    55         {
 
    55         return r;
 
    56         TRequestStatus stat;
 
    56         }
 
    57         server.Rendezvous(stat);
 
    57 
    58 
    58     TRequestStatus stat;
 
    59         if (stat != KRequestPending)
 
    59     server.Rendezvous(stat);
 
    60             {
 
    60 
    61             server.Kill(0); // abort startup
 
    61     if (stat != KRequestPending)
 
    62             }
 
    62         {
 
    63         else
 
    63         server.Kill(0); // abort startup
 
    64             {
 
    64         }
 
    65             server.Resume(); // logon OK - start the server
 
    65     else
 
    66             }
 
    66         {
 
    67 
    67         server.Resume(); // logon OK - start the server
 
    68         User::WaitForRequest(stat); // wait for start or death
 
    68         }
 
    69 
    69 
    70         // We can't use the 'exit reason' if the server panicked, as '0' is a
 
    70     User::WaitForRequest(stat); // wait for start or death
 
    71         // valid panic 'reason', which cannot be distinguished from
 
    71 
    72         // TMS_RESULT_SUCCESS.
 
    72     // Panic reason cannot be '0' as it would conflict with TMS_RESULT_SUCCESS
 
    73         ret = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
 
    73     r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
 
    74         server.Close();
 
    74     server.Close();
 
    75         }
 
    75     return r;
 
    76 
       
    77     return ret;
 
    76     }
 
    78     }
 
    77 
    79 
    78 // -----------------------------------------------------------------------------
 
    80 // -----------------------------------------------------------------------------
 
    79 // TMSProxy::TMSProxy
 
    81 // TMSProxy::TMSProxy
 
    80 // -----------------------------------------------------------------------------
 
    82 // -----------------------------------------------------------------------------
 
   437                 // Convert buffer from UTF-8 to unicode (16-bit)
 
   439                 // Convert buffer from UTF-8 to unicode (16-bit)
 
   438                 // Note: UTF-8 strings can take up to 4 bytes per character
 
   440                 // Note: UTF-8 strings can take up to 4 bytes per character
 
   439                 gint unilen = str->len / KUTF8Multiply;
 
   441                 gint unilen = str->len / KUTF8Multiply;
 
   440 
   442 
   441                 TRAP(status, buf = HBufC::NewL(unilen));
 
   443                 TRAP(status, buf = HBufC::NewL(unilen));
 
   442                 if (status == KErrNone)
 
   444                 if (buf && status == KErrNone)
 
   443                     {
 
   445                     {
 
   444                     TPtr p = buf->Des();
 
   446                     TPtr p = buf->Des();
 
   445                     p.Copy((TUint16*) str->str, unilen);
 
   447                     p.Copy((TUint16*) str->str, unilen);
 
   446                     TIpcArgs args;
 
   448                     TIpcArgs args;
 
   447                     args.Set(0, &p);
 
   449                     args.Set(0, &p);
 
   473             if (str)
 
   475             if (str)
 
   474                 {
 
   476                 {
 
   475                 HBufC8* buf(NULL);
 
   477                 HBufC8* buf(NULL);
 
   476                 gint len = str->len;
 
   478                 gint len = str->len;
 
   477                 TRAP(status, buf = HBufC8::NewL(len));
 
   479                 TRAP(status, buf = HBufC8::NewL(len));
 
   478                 if (status == KErrNone)
 
   480                 if (buf && status == KErrNone)
 
   479                     {
 
   481                     {
 
   480                     TPtr8 p = buf->Des();
 
   482                     TPtr8 p = buf->Des();
 
   481                     p.Copy((TUint8*) str->str, len);
 
   483                     p.Copy((TUint8*) str->str, len);
 
   482                     TIpcArgs args;
 
   484                     TIpcArgs args;
 
   483                     args.Set(0, &p);
 
   485                     args.Set(0, &p);
 
   536     }
 
   538     }
 
   537 
   539 
   538 EXPORT_C gint TMSProxy::StartDTMF(TMSStreamType streamtype, GString* tone)
 
   540 EXPORT_C gint TMSProxy::StartDTMF(TMSStreamType streamtype, GString* tone)
 
   539     {
 
   541     {
 
   540     TRACE_PRN_FN_ENT;
 
   542     TRACE_PRN_FN_ENT;
 
   541     gint status(TMS_RESULT_SUCCESS);
 
   543     __ASSERT_ALWAYS(tone, PANIC(TMS_RESULT_NULL_ARGUMENT));
 
   542 
   544 
       
   545     gint status(TMS_RESULT_SUCCESS);
 
   543     HBufC* buf(NULL);
 
   546     HBufC* buf(NULL);
 
   544     TRAP(status, buf = HBufC::NewL(tone->len));
 
   547     TRAP(status, buf = HBufC::NewL(tone->len));
 
   545     if (status == KErrNone)
 
   548     if (status == KErrNone)
 
   546         {
 
   549         {
 
   547         TPtr p1 = buf->Des();
 
   550         TPtr p1 = buf->Des();
 
   553         TIpcArgs args;
 
   556         TIpcArgs args;
 
   554         args.Set(0, streamtype);
 
   557         args.Set(0, streamtype);
 
   555         args.Set(1, &p1);
 
   558         args.Set(1, &p1);
 
   556         status = RSessionBase::SendReceive(ETMSStartDTMF, args);
 
   559         status = RSessionBase::SendReceive(ETMSStartDTMF, args);
 
   557         }
 
   560         }
 
   558 
       
   559     delete buf;
 
   561     delete buf;
 
   560     buf = NULL;
 
   562     buf = NULL;
 
   561 
       
   562     TRACE_PRN_FN_EXT;
 
   563     TRACE_PRN_FN_EXT;
 
   563     return TMSRESULT(status);
 
   564     return TMSRESULT(status);
 
   564     }
 
   565     }
 
   565 
   566 
   566 EXPORT_C gint TMSProxy::StopDTMF(TMSStreamType streamtype)
 
   567 EXPORT_C gint TMSProxy::StopDTMF(TMSStreamType streamtype)
 
   963 //
 
   964 //
 
   964 void TMSProxy::QueueEvent(gint aEventType, gint aError, void* event_data)
 
   965 void TMSProxy::QueueEvent(gint aEventType, gint aError, void* event_data)
 
   965     {
 
   966     {
 
   966     TMSSignalEvent event = {}; //all elements initialized to zeros
 
   967     TMSSignalEvent event = {}; //all elements initialized to zeros
 
   967     event.type = aEventType;
 
   968     event.type = aEventType;
 
   968     event.reason = aError;
 
   969     event.reason = TMSRESULT(aError);
 
   969     event.user_data = NULL; //use only to return data passed in by the user
 
   970     event.user_data = NULL; //use only to return data passed in by the user
 
   970 
   971 
   971     switch (aEventType)
 
   972     switch (aEventType)
 
   972         {
 
   973         {
 
   973         case TMS_EVENT_EFFECT_VOL_CHANGED:
 
   974         case TMS_EVENT_EFFECT_VOL_CHANGED:
FCL/sf/mw/mmmw