19 #include <gstring.h>

    23 #include <tmsringtoneobsrvr.h>

    24 #include <tmsdtmfobsrvr.h>

    25 #include <tmsinbandtoneobsrvr.h>

   399     TRACE_PRN_FN_EXT;

   400     return TMSRESULT(status);

   401     }

   402 

   403 EXPORT_C gint TMSProxy::InitRT(const TMSRingToneType type, GString* str,

   404         GString* tts)

   405     {

   406     TRACE_PRN_FN_ENT;

   407     gint status(TMS_RESULT_INVALID_ARGUMENT);

   408     TIpcArgs args;

   409     HBufC* ttsBuf(NULL);

   410 

   411     if (tts)

   412         {

   413         // Convert buffer from UTF-8 to unicode (16-bit)

   414         // Note: UTF-8 strings can take up to 4 bytes per character

   415         guint unilen = tts->len / KUTF8Multiply;

   416         TRAP(status, ttsBuf = HBufC::NewL(unilen));

   417         if (status == KErrNone)

   418             {

   419             TPtr p = ttsBuf->Des();

   420             p.Copy((TUint16*) tts->str, unilen);

   421             args.Set(1, &p);

   422             }

   423         }

   424 

   425     switch (type)

   426         {

   427         case TMS_RINGTONE_DEFAULT:

   428             {

   429             status = RSessionBase::SendReceive(ETMSRingToneInitDefault, args);

   430             break;

   431             }

   432         case TMS_RINGTONE_FILE:

   433             {

   434             if (str)

   435                 {

   436                 HBufC* buf(NULL);

   437                 // Convert buffer from UTF-8 to unicode (16-bit)

   438                 // Note: UTF-8 strings can take up to 4 bytes per character

   439                 guint unilen = str->len / KUTF8Multiply;

   440 

   441                 TRAP(status, buf = HBufC::NewL(unilen));

   442                 if (buf && status == KErrNone)

   443                     {

   444                     TPtr p = buf->Des();

   445                     p.Copy((TUint16*) str->str, unilen);

   446                     TIpcArgs args;

   447                     args.Set(0, &p);

   448                     status = RSessionBase::SendReceive(ETMSRingToneInitFile,

   449                             args);

   450                     }

   451                 delete buf;

   452                 buf = NULL;

   453                 }

   454             break;

   455             }

   456         case TMS_RINGTONE_BEEP_ONCE:

   457             {

   458             status = RSessionBase::SendReceive(ETMSRingToneInitBeepOnce);

   459             break;

   460             }

   461         case TMS_RINGTONE_SILENT:

   462             {

   463             status = RSessionBase::SendReceive(ETMSRingToneInitSilent);

   464             break;

   465             }

   466         case TMS_RINGTONE_UNSECURE_VOIP:

   467             {

   468             status = RSessionBase::SendReceive(ETMSRingToneInitUnsecureVoIP);

   469             break;

   470             }

   471         case TMS_RINGTONE_SEQUENCE:

   472             {

   473             if (str)

   474                 {

   475                 HBufC8* buf(NULL);

   476                 gint len = str->len;

   477                 TRAP(status, buf = HBufC8::NewL(len));

   478                 if (buf && status == KErrNone)

   479                     {

   480                     TPtr8 p = buf->Des();

   481                     p.Copy((TUint8*) str->str, len);

   482                     TIpcArgs args;

   483                     args.Set(0, &p);

   484                     status = RSessionBase::SendReceive(

   485                             ETMSRingToneInitSequence, args);

   486                     }

   487                 delete buf;

   488                 buf = NULL;

   489                 }

   490             break;

   491             }

   492         default:

   493             break;

   494         }

   495 

   496     delete ttsBuf;

   497     ttsBuf = NULL;

   498 

   499     TRACE_PRN_FN_EXT;

   500     return TMSRESULT(status);

   501     }

   502 

   503 EXPORT_C gint TMSProxy::DeinitRT()

   504     {

   505     gint status(TMS_RESULT_SUCCESS);

   506     status = RSessionBase::SendReceive(ETMSRingToneDeinit);

   507     return TMSRESULT(status);

   508     }

   509 

   510 EXPORT_C gint TMSProxy::PlayRT()

   511     {

   512     gint status(TMS_RESULT_SUCCESS);

   513     status = RSessionBase::SendReceive(ETMSRingTonePlay);

   514     return TMSRESULT(status);

   515     }

   516 

   517 EXPORT_C gint TMSProxy::StopRT()

   518     {

   519     gint status(TMS_RESULT_SUCCESS);

   520     status = RSessionBase::SendReceive(ETMSRingToneStop);

   521     return TMSRESULT(status);

   522     }

   523 

   524 EXPORT_C gint TMSProxy::PauseRT()

   525     {

   526     gint status(TMS_RESULT_SUCCESS);

   527     status = RSessionBase::SendReceive(ETMSRingTonePause);

   528     return TMSRESULT(status);

   529     }

   530 

   531 EXPORT_C gint TMSProxy::MuteRT()

   532     {

   533     gint status(TMS_RESULT_SUCCESS);

   534     status = RSessionBase::SendReceive(ETMSRingToneMute);

   535     return TMSRESULT(status);

   536     }

   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 

   547 EXPORT_C gint TMSProxy::StartDTMF(TMSStreamType streamtype, GString* tone)

   548     {

   549     TRACE_PRN_FN_ENT;

   550     __ASSERT_ALWAYS(tone, PANIC(TMS_RESULT_NULL_ARGUMENT));

   551 

   552     gint status(TMS_RESULT_SUCCESS);

   553     HBufC* buf(NULL);

   554     TRAP(status, buf = HBufC::NewL(tone->len));

   555     if (status == KErrNone)

   556         {

   557         TPtr p1 = buf->Des();

   558         TPtr8 p2((TUint8*) tone->str, tone->len, tone->len);

   559         p1.Copy(p2);

   560 

   561         TRACE_PRN_N(p1);

   562 

   563         TIpcArgs args;

   564         args.Set(0, streamtype);

   565         args.Set(1, &p1);

   566         status = RSessionBase::SendReceive(ETMSStartDTMF, args);

   567         }

   568     delete buf;

   569     buf = NULL;

   570     TRACE_PRN_FN_EXT;

   571     return TMSRESULT(status);

   572     }

   573 

   574 EXPORT_C gint TMSProxy::StopDTMF(TMSStreamType streamtype)

   575     {

   576     TRACE_PRN_FN_ENT;

   577     gint status(TMS_RESULT_SUCCESS);

   578     status = RSessionBase::SendReceive(ETMSStopDTMF, TIpcArgs(streamtype));

   579     TRACE_PRN_FN_EXT;

   580     return TMSRESULT(status);

   581     }

   582 

   583 EXPORT_C gint TMSProxy::ContinueDTMFStringSending(gboolean continuesending)

   584     {

   585     TRACE_PRN_FN_ENT;

   586     gint status(TMS_RESULT_SUCCESS);

   587     status = RSessionBase::SendReceive(ETMSContinueDTMF,

   588             TIpcArgs(continuesending));

   589     TRACE_PRN_FN_EXT;

   590     return TMSRESULT(status);

   591     }

   592 

   593 EXPORT_C gint TMSProxy::StartInbandTone(TMSInbandToneType inbandtonetype)

   594     {

   595     TRACE_PRN_FN_ENT;

   596     gint status(TMS_RESULT_SUCCESS);

   597     status = RSessionBase::SendReceive(ETMSStartInbandTone,

   598             TIpcArgs(inbandtonetype));

   599     TRACE_PRN_FN_EXT;

   600     return TMSRESULT(status);

   601     }

   602 

   603 EXPORT_C gint TMSProxy::StopInbandTone()

   604     {

   605     TRACE_PRN_FN_ENT;

   606     gint status(TMS_RESULT_SUCCESS);

   607     status = RSessionBase::SendReceive(ETMSStopInbandTone);

   661         case EMsgQueueRingtoneType:

   662             status = AddRingToneObserver(

   663                     *(static_cast<TMSRingToneObserver*>(obsrv)),

   664                     *(static_cast<TMSRingTone*>(parent)), clientid);

   665             break;

   666         case EMsgQueueDTMFType:

   667             status = AddDTMFObserver(*(static_cast<TMSDTMFObserver*>(obsrv)),

   668                     *(static_cast<TMSDTMF*>(parent)), clientid);

   669             break;

   670         case EMsgQueueInbandToneType:

   671             status = AddInbandToneObserver(

   672                     *(static_cast<TMSInbandToneObserver*>(obsrv)),

   673                     *(static_cast<TMSInbandTone*>(parent)), clientid);

   674             break;

   701             break;

   702         case EMsgQueueRingtoneType:

   703             status = RemoveRingToneObserver(

   704                     *(static_cast<TMSRingToneObserver*>(obsrv)));

   705             break;

   706         case EMsgQueueDTMFType:

   707             status = RemoveDTMFObserver(

   708                     *(static_cast<TMSDTMFObserver*>(obsrv)));

   709             break;

   710         case EMsgQueueInbandToneType:

   711             status = RemoveInbandToneObserver(

   712                     *(static_cast<TMSInbandToneObserver*>(obsrv)));

   801         }

   802     else

   803         {

   804         status = TMS_RESULT_DOES_NOT_EXIST;

   805         }

   806     return TMSRESULT(status);

   807     }

   808 

   809 gint TMSProxy::AddRingToneObserver(TMSRingToneObserver& obsrv,

   810         TMSRingTone& parent, gint /*clientid*/)

   811     {

   812     gint status = iRingToneObsrvrList.Find(&obsrv);

   813     if (status == KErrNotFound)

   814         {

   815         status = iRingToneObsrvrList.Append(&obsrv);

   816         status = iRingToneParentList.Append(&parent);

   817         }

   818     else

   819         {

   820         status = TMS_RESULT_ALREADY_EXIST;

   821         }

   822     return TMSRESULT(status);

   823     }

   824 

   825 gint TMSProxy::RemoveRingToneObserver(TMSRingToneObserver& obsrv)

   826     {

   827     gint status(TMS_RESULT_SUCCESS);

   828     gint index = iRingToneObsrvrList.Find(&obsrv);

   829     if (index >= 0)

   830         {

   831         iRingToneObsrvrList.Remove(index);

   832         iRingToneParentList.Remove(index);

   833         }

   834     else

   835         {

   836         status = TMS_RESULT_DOES_NOT_EXIST;

   837         }

   838     return TMSRESULT(status);

   839     }

   840 

   841 gint TMSProxy::AddDTMFObserver(TMSDTMFObserver& obsrv, TMSDTMF& parent,

   842         gint /*clientid*/)

   843     {

   844     // Add to list if observer is not already added

   845     gint status = iDTMFObsrvrList.Find(&obsrv);

   846     if (status == KErrNotFound)

   847         {

   848         status = iDTMFObsrvrList.Append(&obsrv);

   849         status = iDTMFParentList.Append(&parent);

   850         }

   851     else

   852         {

   853         status = TMS_RESULT_ALREADY_EXIST;

   854         }

   855     return TMSRESULT(status);

   856     }

   857 

   858 gint TMSProxy::RemoveDTMFObserver(TMSDTMFObserver& obsrv)

   859     {

   860     gint status(TMS_RESULT_SUCCESS);

   861     gint index = iDTMFObsrvrList.Find(&obsrv);

   862     if (index >= 0)

   863         {

   864         iDTMFObsrvrList.Remove(index);

   865         iDTMFParentList.Remove(index);

   866         }

   867     else

   868         {

   869         status = TMS_RESULT_DOES_NOT_EXIST;

   870         }

   871     return TMSRESULT(status);

   872     }

   873 

   874 gint TMSProxy::AddInbandToneObserver(TMSInbandToneObserver& obsrv,

   875         TMSInbandTone& parent, gint /*clientid*/)

   876     {

   877     // Add to list if observer is not already added

   878     gint status = iInbandToneObsrvrList.Find(&obsrv);

   879     if (status == KErrNotFound)

   880         {

   881         status = iInbandToneObsrvrList.Append(&obsrv);

   882         status = iInbandToneParentList.Append(&parent);

   883         }

   884     else

   885         {

   886         status = TMS_RESULT_ALREADY_EXIST;

   887         }

   888     return TMSRESULT(status);

   889     }

   890 

   891 gint TMSProxy::RemoveInbandToneObserver(TMSInbandToneObserver& obsrv)

   892     {

   893     gint status(TMS_RESULT_SUCCESS);

   894     gint index = iInbandToneObsrvrList.Find(&obsrv);

   895     if (index >= 0)

   896         {

   897         iInbandToneObsrvrList.Remove(index);

   898         iInbandToneParentList.Remove(index);

  1005         case TMS_EVENT_RINGTONE_OPEN_COMPLETE:

  1006         case TMS_EVENT_RINGTONE_PLAY_COMPLETE:

  1007         case TMS_EVENT_RINGTONE_DEINIT_COMPLETE:

  1008             {

  1009             for (gint i = 0; i < iRingToneObsrvrList.Count(); i++)

  1010                 {

  1011                 iRingToneObsrvrList[i]->RingtoneEvent(*iRingToneParentList[i],

  1012                         event);

  1013                 }

  1014             break;

  1015             }

  1016         case TMS_EVENT_DTMF_TONE_STARTED:

  1017         case TMS_EVENT_DTMF_TONE_STOPPED:

  1018             {

  1019             for (gint i = 0; i < iDTMFObsrvrList.Count(); i++)

  1020                 {

  1021                 iDTMFObsrvrList[i]->DTMFEvent(*iDTMFParentList[i], event);

  1022                 }

  1023             break;

  1024             }

  1025         case TMS_EVENT_INBAND_TONE_STARTED:

  1026         case TMS_EVENT_INBAND_TONE_STOPPED:

  1027             {

  1028             for (gint i = 0; i < iInbandToneObsrvrList.Count(); i++)

  1029                 {

  1030                 iInbandToneObsrvrList[i]->InbandToneEvent(

  1031                         *iInbandToneParentList[i], event);

  1032                 }

  1033             break;

  1034             }

  1048     iRingToneObsrvrList.Reset();

  1049     iDTMFObsrvrList.Reset();

  1050     iInbandToneObsrvrList.Reset();

  1054     iRingToneParentList.Reset();

  1055     iDTMFParentList.Reset();

  1056     iInbandToneParentList.Reset();