mmserv/tms/tmsserver/src/tmsserver.cpp
changeset 36 73253677b50a
parent 33 5e8b14bae8c3
child 38 9e9fc5ab059f
equal deleted inserted replaced
33:5e8b14bae8c3 36:73253677b50a
    30 #include "tmsglobaleffectssettings.h"
    30 #include "tmsglobaleffectssettings.h"
    31 #include "tmstareventhandler.h"
    31 #include "tmstareventhandler.h"
    32 #include "tmscenrepaudiohandler.h"
    32 #include "tmscenrepaudiohandler.h"
    33 #include "tmsdtmftoneplayer.h"
    33 #include "tmsdtmftoneplayer.h"
    34 #include "tmsdtmfprovider.h"
    34 #include "tmsdtmfprovider.h"
    35 #include "tmsdtmfnotifier.h"
    35 #include "tmspubsublistener.h"
    36 #include "tmsdtmfeventhandler.h"
       
    37 #include "tmsrtparam.h"
    36 #include "tmsrtparam.h"
    38 #include "tmsserver.h"
    37 #include "tmsserver.h"
    39 
    38 
    40 using namespace TMS;
    39 using namespace TMS;
    41 
    40 
    84     iUplCodecs.Reset();
    83     iUplCodecs.Reset();
    85     iUplCodecs.Close();
    84     iUplCodecs.Close();
    86     delete iEffectSettings;
    85     delete iEffectSettings;
    87     delete iTarHandler;
    86     delete iTarHandler;
    88     delete iAudioCenRepHandler;
    87     delete iAudioCenRepHandler;
    89     delete iDTMFHandler;
       
    90     DeinitRingTonePlayer();
    88     DeinitRingTonePlayer();
    91     delete iTMSRtPlayer;
    89     delete iTMSRtPlayer;
    92     delete iDTMFUplinkPlayer;
    90     delete iDTMFUplinkPlayer;
    93     delete iDTMFUplinkPlayerEtel;
    91     delete iDTMFUplinkPlayerEtel;
    94     delete iDTMFDnlinkPlayer;
    92     delete iDTMFDnlinkPlayer;
    95     delete iDTMFNotifier;
    93     delete iSyncVol;
    96 
       
    97     TRACE_PRN_FN_EXT;
    94     TRACE_PRN_FN_EXT;
    98     }
    95     }
    99 
    96 
   100 // -----------------------------------------------------------------------------
    97 // -----------------------------------------------------------------------------
   101 // TMSServer::NewSessionL
    98 // TMSServer::NewSessionL
   139     StartL(KTMSServerName);
   136     StartL(KTMSServerName);
   140     RThread().SetPriority(EPriorityRealTime);
   137     RThread().SetPriority(EPriorityRealTime);
   141     iEffectSettings = TMSGlobalEffectsSettings::NewL();
   138     iEffectSettings = TMSGlobalEffectsSettings::NewL();
   142     iTarHandler = NULL;
   139     iTarHandler = NULL;
   143     iAudioCenRepHandler = NULL;
   140     iAudioCenRepHandler = NULL;
   144     iDTMFHandler = NULL;
       
   145     iCurrentRouting = TMS_AUDIO_OUTPUT_PRIVATE;
   141     iCurrentRouting = TMS_AUDIO_OUTPUT_PRIVATE;
   146     iDTMFDnlinkPlayer = NULL;
   142     iDTMFDnlinkPlayer = NULL;
   147     iDTMFUplinkPlayer = NULL;
   143     iDTMFUplinkPlayer = NULL;
   148     iDTMFUplinkPlayerEtel = NULL;
   144     iDTMFUplinkPlayerEtel = NULL;
   149     iDTMFNotifier = NULL;
   145     iSyncVol = TMSPubSubListener::NewL(KTMSPropertyCategory,ESyncVolume, this);
   150 
   146 
   151     //TODO: EUnit fails to initialize ProfileEngine in RT in eshell mode
   147     //TODO: EUnit fails to initialize ProfileEngine in RT in eshell mode
   152     TRAP_IGNORE(InitRingTonePlayerL());
   148     TRAP_IGNORE(InitRingTonePlayerL());
   153 
   149 
   154     // We need it running for global volume change updates
   150     // We need it running for global volume change updates
   266                 {
   262                 {
   267                 case TMS_AUDIO_OUTPUT_PUBLIC:
   263                 case TMS_AUDIO_OUTPUT_PUBLIC:
   268                 case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
   264                 case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
   269                     {
   265                     {
   270                     iEffectSettings->GetLoudSpkrVolume(volume);
   266                     iEffectSettings->GetLoudSpkrVolume(volume);
       
   267                     TRACE_PRN_N1(_L("loudspk vol %d"),volume);
   271                     }
   268                     }
   272                     break;
   269                     break;
   273                 default:
   270                 default:
   274                     {
   271                     {
   275                     iEffectSettings->GetEarPieceVolume(volume);
   272                     iEffectSettings->GetEarPieceVolume(volume);
       
   273                     TRACE_PRN_N1(_L("ear vol %d"),volume);
   276                     }
   274                     }
   277                     break;
   275                     break;
   278                 }
   276                 }
   279             aHandle.SendToCallServer(TMS_EFFECT_GLOBAL_VOL_SET, volume);
   277             aHandle.SendToCallServer(TMS_EFFECT_GLOBAL_VOL_SET, volume);
   280             aHandle.SendToCallServer(TMS_EFFECT_GLOBAL_GAIN_SET,
   278             aHandle.SendToCallServer(TMS_EFFECT_GLOBAL_GAIN_SET,
   354     {
   352     {
   355     if (--iAudioCenRepHandlerCount <= 0)
   353     if (--iAudioCenRepHandlerCount <= 0)
   356         {
   354         {
   357         delete iAudioCenRepHandler;
   355         delete iAudioCenRepHandler;
   358         iAudioCenRepHandler = NULL;
   356         iAudioCenRepHandler = NULL;
   359         }
       
   360     }
       
   361 
       
   362 // -----------------------------------------------------------------------------
       
   363 // TMSServer::StartDTMFNotifierL
       
   364 //
       
   365 // -----------------------------------------------------------------------------
       
   366 //
       
   367 void TMSServer::StartDTMFNotifierL()
       
   368     {
       
   369     TRACE_PRN_FN_ENT;
       
   370 
       
   371     if (!iDTMFHandler)
       
   372         {
       
   373         iDTMFHandlerCount = 0;
       
   374         iDTMFHandler = TMSDtmfEventHandler::NewL(
       
   375                 (const_cast<TMSServer*> (this)));
       
   376         }
       
   377     iDTMFHandlerCount++;
       
   378 
       
   379     TRACE_PRN_FN_EXT;
       
   380     }
       
   381 
       
   382 // -----------------------------------------------------------------------------
       
   383 // TMSServer::CancelDTMFNotifier
       
   384 //
       
   385 // -----------------------------------------------------------------------------
       
   386 //
       
   387 void TMSServer::CancelDTMFNotifier()
       
   388     {
       
   389     if (--iDTMFHandlerCount <= 0)
       
   390         {
       
   391         delete iDTMFHandler;
       
   392         iDTMFHandler = NULL;
       
   393         }
   357         }
   394     }
   358     }
   395 
   359 
   396 // -----------------------------------------------------------------------------
   360 // -----------------------------------------------------------------------------
   397 // TMSServer::SetOutput
   361 // TMSServer::SetOutput
   577     switch (iCurrentRouting)
   541     switch (iCurrentRouting)
   578         {
   542         {
   579         case TMS_AUDIO_OUTPUT_PUBLIC:
   543         case TMS_AUDIO_OUTPUT_PUBLIC:
   580         case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
   544         case TMS_AUDIO_OUTPUT_LOUDSPEAKER:
   581             iEffectSettings->GetLoudSpkrVolume(volume);
   545             iEffectSettings->GetLoudSpkrVolume(volume);
       
   546             TRACE_PRN_N1(_L("TMSServer::GetLevel loudspkr vol %d"),volume);
   582             break;
   547             break;
   583         default:
   548         default:
   584             iEffectSettings->GetEarPieceVolume(volume);
   549             iEffectSettings->GetEarPieceVolume(volume);
       
   550             TRACE_PRN_N1(_L("TMSServer::GetLevel ear vol %d"),volume);
   585             break;
   551             break;
   586         }
   552         }
   587 
   553 
   588     pckg() = volume;
   554     pckg() = volume;
   589     if (status == TMS_RESULT_SUCCESS)
   555     if (status == TMS_RESULT_SUCCESS)
   837     iCurrentRouting = routingpckg().iOutput;
   803     iCurrentRouting = routingpckg().iOutput;
   838     if (iCurrentRouting == TMS_AUDIO_OUTPUT_PUBLIC ||
   804     if (iCurrentRouting == TMS_AUDIO_OUTPUT_PUBLIC ||
   839             iCurrentRouting == TMS_AUDIO_OUTPUT_LOUDSPEAKER)
   805             iCurrentRouting == TMS_AUDIO_OUTPUT_LOUDSPEAKER)
   840         {
   806         {
   841         iEffectSettings->GetLoudSpkrVolume(vol);
   807         iEffectSettings->GetLoudSpkrVolume(vol);
       
   808         TRACE_PRN_N1(_L("TMSServer::NotifyTarClients loudspkr vol %d"),vol);
   842         }
   809         }
   843     else
   810     else
   844         {
   811         {
   845         iEffectSettings->GetEarPieceVolume(vol);
   812         iEffectSettings->GetEarPieceVolume(vol);
       
   813         TRACE_PRN_N1(_L("TMSServer::NotifyTarClients ear vol %d"),vol);
   846         }
   814         }
   847 
   815 
   848     TInt status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_VOL_SET, vol);
   816     TInt status = SendMessageToCallServ(TMS_EFFECT_GLOBAL_VOL_SET, vol);
   849 
   817 
   850     iSessionIter.SetToFirst();
   818     iSessionIter.SetToFirst();
   888                 iDTMFUplinkPlayerEtel->AddObserver(*this);
   856                 iDTMFUplinkPlayerEtel->AddObserver(*this);
   889                 }
   857                 }
   890             }
   858             }
   891         if (!iDTMFUplinkPlayer) //IP call
   859         if (!iDTMFUplinkPlayer) //IP call
   892             {
   860             {
       
   861             // TODO: Ongoing work with Audio Policy team...
   893             TRAP(status, iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
   862             TRAP(status, iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
   894 //                    KAudioPrefVoipAudioUplinkNonSignal,
   863 //                    KAudioPrefVoipAudioUplinkNonSignal,
   895 //                    KAudioPrefVoipAudioUplink,
   864 //                    KAudioPrefVoipAudioUplink,
   896 //                    KAudioPrefUnknownVoipAudioUplink
   865 //                    KAudioPrefUnknownVoipAudioUplink
   897 //                    KAudioPriorityDTMFString));
   866 //                    KAudioPriorityDTMFString));
   904             {
   873             {
   905             TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
   874             TRAP(status, iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this,
   906                     KAudioDTMFString, KAudioPriorityDTMFString));
   875                     KAudioDTMFString, KAudioPriorityDTMFString));
   907             }
   876             }
   908         }
   877         }
   909     if (!iDTMFNotifier && status == TMS_RESULT_SUCCESS)
       
   910         {
       
   911         TRAP(status, iDTMFNotifier = TMSDtmfNotifier::NewL());
       
   912         }
       
   913 
   878 
   914     aMessage.Complete(status);
   879     aMessage.Complete(status);
   915     TRACE_PRN_FN_EXT;
   880     TRACE_PRN_FN_EXT;
   916     return status;
   881     return status;
   917     }
   882     }
   937         if (status == TMS_RESULT_SUCCESS)
   902         if (status == TMS_RESULT_SUCCESS)
   938             {
   903             {
   939             TPtr ptr = tone->Des();
   904             TPtr ptr = tone->Des();
   940             status = aMessage.Read(1, ptr);
   905             status = aMessage.Read(1, ptr);
   941             TRACE_PRN_N(ptr);
   906             TRACE_PRN_N(ptr);
   942             TmsMsgBufPckg dtmfpckg;
       
   943             dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
       
   944 
   907 
   945             if (strmtype == TMS_STREAM_UPLINK)
   908             if (strmtype == TMS_STREAM_UPLINK)
   946                 {
   909                 {
   947 //#ifdef __WINSCW__
   910 #ifdef __WINSCW__
   948                 // Just to test playback in wins
   911                 // Just to hear DTMF tones in Wins
   949 //                iActiveCallType = TMS_CALL_IP;
   912                 iActiveCallType = TMS_CALL_IP;
   950 //#else
   913 #else
   951                 FindActiveCallType();
   914                 FindActiveCallType();
   952 //#endif
   915 #endif
   953                 if (iActiveCallType == TMS_CALL_IP && iDTMFUplinkPlayer)
   916                 if (iActiveCallType == TMS_CALL_IP && iDTMFUplinkPlayer)
   954                     {
   917                     {
   955                     iDTMFUplinkPlayer->PlayDtmfTone(ptr);
   918                     iDTMFUplinkPlayer->PlayDtmfTone(ptr);
   956                     status = TMS_RESULT_SUCCESS;
   919                     status = TMS_RESULT_SUCCESS;
   957                     dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted;
       
   958                     }
   920                     }
   959                 else if (iActiveCallType == TMS_CALL_CS &&
   921                 else if (iActiveCallType == TMS_CALL_CS &&
   960                         iDTMFUplinkPlayerEtel)
   922                         iDTMFUplinkPlayerEtel)
   961                     {
   923                     {
   962                     status = iDTMFUplinkPlayerEtel->SendDtmfToneString(ptr);
   924                     status = iDTMFUplinkPlayerEtel->SendDtmfToneString(ptr);
   963                     dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted;
       
   964                     }
   925                     }
   965                 else
   926                 else
   966                     {
   927                     {
   967                     status = TMS_RESULT_INVALID_STATE;
   928                     status = TMS_RESULT_INVALID_STATE;
   968                     }
   929                     }
       
   930                 NotifyDtmfClients(ECmdDTMFToneUplPlayStarted, status);
   969                 }
   931                 }
   970             else if (strmtype == TMS_STREAM_DOWNLINK)
   932             else if (strmtype == TMS_STREAM_DOWNLINK)
   971                 {
   933                 {
   972                 //status = TMS_RESULT_UNINITIALIZED_OBJECT;
   934                 status = TMS_RESULT_INVALID_STATE;
   973                 if (iDTMFDnlinkPlayer)
   935                 if (iDTMFDnlinkPlayer)
   974                     {
   936                     {
   975                     iDTMFDnlinkPlayer->PlayDtmfTone(ptr);
   937                     iDTMFDnlinkPlayer->PlayDtmfTone(ptr);
   976                     status = TMS_RESULT_SUCCESS;
   938                     status = TMS_RESULT_SUCCESS;
   977                     dtmfpckg().iRequest = ECmdDTMFToneDnlPlayStarted;
       
   978                     }
   939                     }
       
   940                 NotifyDtmfClients(ECmdDTMFToneDnlPlayStarted, status);
   979                 }
   941                 }
   980             else
   942             else
   981                 {
   943                 {
   982                 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
   944                 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED;
   983                 }
   945                 }
   984 
       
   985             if (iDTMFNotifier)
       
   986                 {
       
   987                 dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status);
       
   988                 iDTMFNotifier->SetDtmf(dtmfpckg);
       
   989                 }
       
   990             }
   946             }
   991         delete tone;
   947         delete tone;
   992         tone = NULL;
   948         tone = NULL;
   993         }
   949         }
   994 
   950 
  1030             {
   986             {
  1031             iDTMFDnlinkPlayer->Cancel();
   987             iDTMFDnlinkPlayer->Cancel();
  1032             status = TMS_RESULT_SUCCESS;
   988             status = TMS_RESULT_SUCCESS;
  1033             }
   989             }
  1034         }
   990         }
  1035     if (iDTMFNotifier)
   991     NotifyDtmfClients(ECmdDTMFTonePlayFinished, status);
  1036         {
       
  1037         TmsMsgBufPckg dtmfpckg;
       
  1038         dtmfpckg().iStatus = status;
       
  1039         dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
       
  1040         iDTMFNotifier->SetDtmf(dtmfpckg);
       
  1041         }
       
  1042 
       
  1043     aMessage.Complete(status);
   992     aMessage.Complete(status);
  1044     TRACE_PRN_FN_EXT;
   993     TRACE_PRN_FN_EXT;
  1045     return status;
   994     return status;
  1046     }
   995     }
  1047 
   996 
  1071 // -----------------------------------------------------------------------------
  1020 // -----------------------------------------------------------------------------
  1072 // TMSServer::NotifyDtmfClients
  1021 // TMSServer::NotifyDtmfClients
  1073 //
  1022 //
  1074 // -----------------------------------------------------------------------------
  1023 // -----------------------------------------------------------------------------
  1075 //
  1024 //
  1076 TInt TMSServer::NotifyDtmfClients(TmsMsgBufPckg dtmfpckg)
  1025 TInt TMSServer::NotifyDtmfClients(gint aEventType, gint aError)
  1077     {
  1026     {
  1078     TRACE_PRN_FN_ENT;
  1027     TRACE_PRN_FN_ENT;
  1079     iSessionIter.SetToFirst();
  1028     iSessionIter.SetToFirst();
  1080     TMSServerSession* ss = static_cast<TMSServerSession*> (iSessionIter++);
  1029     TMSServerSession* ss = static_cast<TMSServerSession*> (iSessionIter++);
  1081     while (ss != NULL)
  1030     while (ss != NULL)
  1082         {
  1031         {
  1083         ss->NotifyClient(dtmfpckg().iRequest, dtmfpckg().iStatus);
  1032         ss->NotifyClient(aEventType, aError);
  1084         ss = static_cast<TMSServerSession*> (iSessionIter++);
  1033         ss = static_cast<TMSServerSession*> (iSessionIter++);
  1085         }
  1034         }
  1086     TRACE_PRN_FN_EXT;
  1035     TRACE_PRN_FN_EXT;
  1087     return TMS_RESULT_SUCCESS;
  1036     return TMS_RESULT_SUCCESS;
  1088     }
  1037     }
  1091 // -----------------------------------------------------------------------------
  1040 // -----------------------------------------------------------------------------
  1092 // TMSServer::DTMFInitCompleted
  1041 // TMSServer::DTMFInitCompleted
  1093 //
  1042 //
  1094 // -----------------------------------------------------------------------------
  1043 // -----------------------------------------------------------------------------
  1095 //
  1044 //
  1096 void TMSServer::DTMFInitCompleted(gint /*status*/)
  1045 void TMSServer::DTMFInitCompleted(gint status)
  1097     {
  1046     {
  1098     TRACE_PRN_FN_ENT;
  1047     TRACE_PRN_FN_ENT;
  1099     // TODO: process error
  1048     if (status != TMS_RESULT_SUCCESS)
       
  1049         {
       
  1050         NotifyDtmfClients(ECmdDTMFTonePlayFinished, status);
       
  1051         }
  1100     TRACE_PRN_FN_EXT;
  1052     TRACE_PRN_FN_EXT;
  1101     }
  1053     }
  1102 
  1054 
  1103 // -----------------------------------------------------------------------------
  1055 // -----------------------------------------------------------------------------
  1104 // TMSServer::DTMFToneFinished
  1056 // TMSServer::DTMFToneFinished
  1107 //
  1059 //
  1108 void TMSServer::DTMFToneFinished(gint status)
  1060 void TMSServer::DTMFToneFinished(gint status)
  1109     {
  1061     {
  1110     TRACE_PRN_FN_ENT;
  1062     TRACE_PRN_FN_ENT;
  1111     TRACE_PRN_IF_ERR(status);
  1063     TRACE_PRN_IF_ERR(status);
  1112     TmsMsgBufPckg dtmfpckg;
       
  1113 
  1064 
  1114     // KErrUnderflow indicates end of DTMF playback.
  1065     // KErrUnderflow indicates end of DTMF playback.
  1115     if (status == KErrUnderflow /*|| status == KErrInUse*/)
  1066     if (status == KErrUnderflow /*|| status == KErrInUse*/)
  1116         {
  1067         {
  1117         status = TMS_RESULT_SUCCESS;
  1068         status = TMS_RESULT_SUCCESS;
  1118         }
  1069         }
  1119     dtmfpckg().iStatus = TMSRESULT(status);
  1070     NotifyDtmfClients(ECmdDTMFTonePlayFinished, status);
  1120     dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
       
  1121     if (iDTMFNotifier)
       
  1122         {
       
  1123         iDTMFNotifier->SetDtmf(dtmfpckg);
       
  1124         }
       
  1125     TRACE_PRN_FN_EXT;
  1071     TRACE_PRN_FN_EXT;
  1126     }
  1072     }
  1127 
  1073 
  1128 // -----------------------------------------------------------------------------
  1074 // -----------------------------------------------------------------------------
  1129 // TMSServer::FindActiveCallType
  1075 // TMSServer::FindActiveCallType
  1163 void TMSServer::HandleDTMFEvent(const TMSDTMFObserver::TCCPDtmfEvent event,
  1109 void TMSServer::HandleDTMFEvent(const TMSDTMFObserver::TCCPDtmfEvent event,
  1164         const gint status, const TChar /*tone*/)
  1110         const gint status, const TChar /*tone*/)
  1165     {
  1111     {
  1166     TRACE_PRN_FN_ENT;
  1112     TRACE_PRN_FN_ENT;
  1167     TRACE_PRN_IF_ERR(status);
  1113     TRACE_PRN_IF_ERR(status);
  1168     TmsMsgBufPckg dtmfpckg;
  1114     gint cmd = ECmdDTMFTonePlayFinished;
  1169     dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status);
       
  1170 
  1115 
  1171     switch (event)
  1116     switch (event)
  1172         {
  1117         {
  1173         case ECCPDtmfUnknown:               //Unknown
  1118         case ECCPDtmfUnknown:               //Unknown
  1174             break;
  1119             break;
  1175         case ECCPDtmfManualStart:           //DTMF sending started manually
  1120         case ECCPDtmfManualStart:           //DTMF sending started manually
  1176         case ECCPDtmfSequenceStart:         //Automatic DTMF sending initialized
  1121         case ECCPDtmfSequenceStart:         //Automatic DTMF sending initialized
  1177             dtmfpckg().iRequest = ECmdDTMFToneUplPlayStarted;
  1122             cmd = ECmdDTMFToneUplPlayStarted;
  1178             break;
  1123             break;
  1179         case ECCPDtmfManualStop:            //DTMF sending stopped manually
  1124         case ECCPDtmfManualStop:            //DTMF sending stopped manually
  1180         case ECCPDtmfManualAbort:           //DTMF sending aborted manually
  1125         case ECCPDtmfManualAbort:           //DTMF sending aborted manually
  1181         case ECCPDtmfSequenceStop:          //Automatic DTMF sending stopped
  1126         case ECCPDtmfSequenceStop:          //Automatic DTMF sending stopped
  1182         case ECCPDtmfSequenceAbort:         //Automatic DTMF sending aborted
  1127         case ECCPDtmfSequenceAbort:         //Automatic DTMF sending aborted
  1183         case ECCPDtmfStopInDtmfString:      //There was stop mark in DTMF string
  1128         case ECCPDtmfStopInDtmfString:      //There was stop mark in DTMF string
  1184         case ECCPDtmfStringSendingCompleted://DTMF sending success
  1129         case ECCPDtmfStringSendingCompleted://DTMF sending success
  1185             dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
       
  1186             break;
       
  1187         default:
  1130         default:
  1188             break;
  1131             break;
  1189         }
  1132         }
  1190 
  1133 
  1191     if (iDTMFNotifier)
  1134     NotifyDtmfClients(cmd, status);
  1192         {
       
  1193         iDTMFNotifier->SetDtmf(dtmfpckg);
       
  1194         }
       
  1195     TRACE_PRN_FN_EXT;
  1135     TRACE_PRN_FN_EXT;
  1196     }
  1136     }
  1197 
  1137 
  1198 // -----------------------------------------------------------------------------
  1138 // -----------------------------------------------------------------------------
  1199 // TMSServer::InitRingTonePlayerL
  1139 // TMSServer::InitRingTonePlayerL
  1480 
  1420 
  1481     TRACE_PRN_FN_EXT;
  1421     TRACE_PRN_FN_EXT;
  1482     }
  1422     }
  1483 
  1423 
  1484 // -----------------------------------------------------------------------------
  1424 // -----------------------------------------------------------------------------
       
  1425 // TMSServer::HandleNotifyPSL
       
  1426 //
       
  1427 // -----------------------------------------------------------------------------
       
  1428 //
       
  1429 void TMSServer::HandleNotifyPSL(const TUid aUid, const TInt& aKey,
       
  1430             const TRequestStatus& aStatus)
       
  1431     {
       
  1432     TRACE_PRN_FN_ENT;
       
  1433     if(iEffectSettings)
       
  1434         {
       
  1435         iEffectSettings->ResetDefaultVolume();
       
  1436         }
       
  1437     TRACE_PRN_FN_EXT;
       
  1438     }
       
  1439 
       
  1440 // -----------------------------------------------------------------------------
  1485 // TMSServer::RunServerL
  1441 // TMSServer::RunServerL
  1486 //
  1442 //
  1487 // -----------------------------------------------------------------------------
  1443 // -----------------------------------------------------------------------------
  1488 //
  1444 //
  1489 void TMSServer::RunServerL()
  1445 void TMSServer::RunServerL()