diff -r a36789189b53 -r 095bea5f582e mmserv/tms/tmsserver/src/tmsrtplayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmserv/tms/tmsserver/src/tmsrtplayer.cpp Tue Aug 31 15:43:02 2010 +0300 @@ -0,0 +1,1712 @@ +/* + * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: Telephony Multimedia Service + * + */ + +// INCLUDE FILES +#include +#include +#include +#include +#include "tmsshared.h" +#include "tmsutility.h" +#include "tmsrtplayerobsrv.h" +#include "tmsrtcontainer.h" +#include "tmsrtplayer.h" + +using namespace TMS; + +// CONSTANTS +const TInt KTMSMaxRingingWaiting = 3000000; +const TInt KTMSTtsAscendingStep = 3000000; +const TInt KRTDefaultVolume = 2; +//const TInt KTtsVolumeBoost = 9; +const TInt KTtsVolumeMin = 2; +const TInt KTtsVolumeAscendingRepeat = 4; +const TInt KPlayerVolumeAscendingRepeat = 3; +const TInt KTtsVolumeAscendingDecrease = 2; + +// Delays between periods of Text-To-Speech playback +// {3000000, 4000000} means the following order of playing: +// 3 secs tone, then TTS, then 4 secs of tone, then TTS, then tone forever. +const TInt KTMSTtsDelays[] = {3000000, 4000000}; +// Number of elements in KTMSTtsDelays array. +const TInt KTMSTtsDelaysCount = sizeof(KTMSTtsDelays) / sizeof (TInt); +const TInt Kkilo = 1024; + +_LIT(KTMSTtsHeader, "(tts)"); + +#ifdef __WINSCW__ +//_LIT(KTMSDefaultSoundFile, "z:\\data\\sounds\\digital\\Nokia_tune.aac"); +_LIT(KTMSDefaultSoundFile, "Z:\\Data\\Sounds\\Digital\\Nokia tune.aac"); +//_LIT(KTMSDefaultSoundFile, "c:\\data\\sounds\\digital\\test_8khz.wav"); +_LIT(KTMSNoSoundSequence, "z:\\data\\sounds\\digital\\clock.aac"); +//_LIT(KTMSNoSoundSequence, "c:\\data\\sounds\\digital\\test_8khz.wav"); +_LIT(KTMSBeepSequence, "z:\\data\\sounds\\digital\\clock.aac"); +//_LIT(KTMSBeepSequence, "c:\\data\\sounds\\digital\\test_8khz.wav"); +_LIT(KTMSUnsecureVoIPCall, "z:\\data\\sounds\\digital\\alarm.aac"); +//_LIT(KTMSUnsecureVoIPCall, "c:\\data\\sounds\\digital\\test_8khz.wav"); +#else +// DO NOT change these sequences! +_LIT(KTMSDefaultSoundFile, "\\System\\Sounds\\Simple\\Nokia tune.wav"); +_LIT8(KTMSBeepSequence, "\x00\x11\x0A\x0A\x08\x73\x0A\x40\x28\x0A\xF7\x05\ +\xFC\x40\x64\x0A\x08\x40\x32\x0A\xF7\x06\x0B"); +_LIT8(KTMSNoSoundSequence, "\x00\x11\x0A\x05\xFC\x0A\x08\x40\x32\x0A\xF7\ +\x40\x64\x06\x0B"); +_LIT8(KTMSUnsecureVoIPCall, "\x00\x11\x0B\x67\x04\x40\x04\x67\x04\x40\x04\ +\x6C\x04\x40\x04\x6D\x04\x0B"); +#endif // __WINSCW__ + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::NewL +// ----------------------------------------------------------------------------- +// +TMSRingTonePlayer* TMSRingTonePlayer::NewL(TMSRtPlayerObsrv& aObserver) + { + TMSRingTonePlayer* self = new (ELeave) TMSRingTonePlayer(aObserver); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::TMSRingTonePlayer +// ----------------------------------------------------------------------------- +// +TMSRingTonePlayer::TMSRingTonePlayer(TMSRtPlayerObsrv& aObserver) : + iRtObserver(aObserver) + { + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::ConstructL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::ConstructL() + { + TRACE_PRN_FN_ENT; + + for (TInt i = EPlayerFirst; i <= EPlayerLast; i++) + { + User::LeaveIfError(iAsyncDeletePlayers.Append(NULL)); + } + + // Construct timer. + iTimer = TMSTimer::NewL(); + iTtsDelayTimer = TMSTimer::NewL(); + iAsyncReqAO = TMSAsyncReqAO::NewL(this); + + // TODO: + // Checks if DRM extend security is needed + // Check video player configuration. + + iEngine = ProEngFactory::NewEngineL(); + + InitRtParams(EPlayerBackup); + //CreateDefaultRingToneL(); + CreateBkpRtPlayerL(); + //GetMaxToneFileSizeL(iToneFileSizeLimitKB); + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::~TMSRingTonePlayer +// ----------------------------------------------------------------------------- +// +TMSRingTonePlayer::~TMSRingTonePlayer() + { + TRACE_PRN_FN_ENT; + + iAsyncDeletePlayers.ResetAndDestroy(); + iAsyncDeletePlayers.Close(); + if (iProfile) + { + iProfile->Release(); + } + if (iEngine) + { + iEngine->Release(); + } + RemovePlayers(); + delete iBackupPlayer; + delete iAsyncReqAO; + delete iTimer; + delete iTtsDelayTimer; + delete iRtContainer; + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::InitRtParams +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::InitRtParams(TRtPlayerType aPlayerType) + { + TRACE_PRN_FN_ENT; + + iRtParam.iType = aPlayerType; + iRtParam.iPriority = KAudioPriorityPhoneCall; + iRtParam.iPreference = KAudioPrefIncomingCall; + iRtParam.iRingingType = EProfileRingingTypeRinging; + iRtParam.iVolume = KRTDefaultVolume; + iRtParam.iTextToSay.Set(KNullDesC()); + + if (aPlayerType == EPlayerUnsecureVoIP) + { + iRtParam.iPriority = KAudioPrioritySpecialInformationTone; + iRtParam.iPreference = KAudioPrefSpecialInformation; + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateDefaultPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateDefaultRingToneL() + { + TRACE_PRN_FN_ENT; + + InitRtParams(EPlayerDefault); + LoadProfileRingToneL(); + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::LoadActiveProfileSettingsL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::LoadActiveProfileSettingsL() + { + if (!iEngine) + { + iEngine = ProEngFactory::NewEngineL(); + } + if (iProfile) + { + iProfile->Release(); + iProfile = NULL; + } + __ASSERT_ALWAYS(iEngine, PANIC(TMS_RESULT_UNINITIALIZED_OBJECT)); + + iProfile = iEngine->ActiveProfileL(); + if (iProfile) + { + MProEngToneSettings& settings = iProfile->ToneSettings(); + iRtParam.iVolume = settings.RingingVolume(); + iRtParam.iRingingType = settings.RingingType(); + iRtParam.iCallerText = settings.TextToSpeech(); + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::LoadProfileRingToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::LoadProfileRingToneL() + { + TRACE_PRN_FN_ENT; + + LoadActiveProfileSettingsL(); + __ASSERT_ALWAYS(iProfile, PANIC(TMS_RESULT_UNINITIALIZED_OBJECT)); + + MProEngTones& tones = iProfile->ProfileTones(); + // Get alternate line RT: tones.RingingTone2() + // Get default video RT: tones.VideoCallRingingTone() + + if (!iRtContainer) + { + iRtContainer = TMSRtContainer::NewL(tones.RingingTone1()); + } + else + { + if (tones.RingingTone1().CompareF(iRtContainer->FileName()) != KErrNone) + { + // Profile changed - update RT + iRtContainer->SetFileName(tones.RingingTone1()); + iRtContainer->RefreshMime(); + } + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateBkpRtPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateBkpRtPlayerL() + { + TRACE_PRN_FN_ENT; + + delete iBackupPlayer; + iBackupPlayer = NULL; + TFileName file(KTMSDefaultSoundFile); + iBackupPlayer = TMSRtAudioHdlr::NewL(file, KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, *this, EPlayerBackup); + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateDefaultRtPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateDefaultRtPlayerL() + { + TRACE_PRN_FN_ENT; + + // Fresh start for the default tone. + CreateDefaultRingToneL(); + + delete iDefaultPlayer; + iDefaultPlayer = NULL; + iDefaultPlayer = TMSRtAudioHdlr::NewL(*iRtContainer, + KAudioPriorityPhoneCall, KAudioPrefIncomingCall, *this, + EPlayerDefault, EFalse); + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateAudioPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateAudioPlayerL() + { + TRACE_PRN_FN_ENT; + + delete iAudioPlayer; + iAudioPlayer = NULL; + iAudioPlayer = TMSRtAudioHdlr::NewL(*iRtContainer, iRtParam.iPriority, + iRtParam.iPreference, *this, iRtParam.iType, + iRtParam.iType == EPlayerDefault ? EFalse : iExtSecNeeded); + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateRingTonePlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateRingTonePlayerL(const TRtPlayerType aPlayer, + const TDesC& aFile) + { + TRACE_PRN_FN_ENT; + + TInt len = aFile.Length(); + if (!len || aPlayer == EPlayerDefault) + { + CreateDefaultRtPlayerL(); + } + else + { + if (!iRtContainer) + { + CreateDefaultRingToneL(); + } + if (len && iRtContainer) + { + iRtContainer->SetFileName(aFile); + iRtContainer->RefreshMime(); + iRtParam.iType = aPlayer; + } + CreateAudioPlayerL(); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateSequencePlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateSequencePlayerL(const TRtPlayerType aPlayer) + { + TRACE_PRN_FN_ENT; + + switch (aPlayer) + { + case EPlayerBeepOnce: + CreateBeepOncePlayerL(); + break; + case EPlayerSilent: + CreateSilentPlayerL(); + break; + case EPlayerUnsecureVoIP: + CreateUnsecureVoipPlayerL(); + break; + default: + break; + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateBeepOncePlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateBeepOncePlayerL() + { + TRACE_PRN_FN_ENT; + + delete iBeepOncePlayer; + iBeepOncePlayer = NULL; + +#ifdef __WINSCW__ + TParse* fp = new (ELeave) TParse(); + fp->Set(KTMSBeepSequence, NULL, NULL); + TFileName fileName(fp->FullName()); + delete fp; + iBeepOncePlayer = TMSRtAudioHdlr::NewL(fileName, iRtParam.iPriority, + iRtParam.iPreference, *this, EPlayerBeepOnce); +#else + iBeepOncePlayer = TMSRtAudioHdlr::NewSeqL(KTMSBeepSequence(), + iRtParam.iPriority, iRtParam.iPreference, *this, EPlayerBeepOnce); +#endif // __WINSCW__ + + iRtParam.iType = EPlayerBeepOnce; + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateSilentPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateSilentPlayerL() + { + TRACE_PRN_FN_ENT; + + iRtParam.iVolume = 0; + delete iSilentPlayer; + iSilentPlayer = NULL; + +#ifdef __WINSCW__ + TParse* fp = new (ELeave) TParse(); + fp->Set(KTMSNoSoundSequence, NULL, NULL); + TFileName fileName(fp->FullName()); + delete fp; + iSilentPlayer = TMSRtAudioHdlr::NewL(fileName, iRtParam.iPriority, + iRtParam.iPreference, *this, EPlayerSilent); +#else + iSilentPlayer = TMSRtAudioHdlr::NewSeqL(KTMSNoSoundSequence(), + iRtParam.iPriority, iRtParam.iPreference, *this, EPlayerSilent); +#endif // __WINSCW__ + + iRtParam.iType = EPlayerSilent; + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateUnsecureVoipPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateUnsecureVoipPlayerL() + { + TRACE_PRN_FN_ENT; + + delete iUnsecureVoIPTonePlayer; + iUnsecureVoIPTonePlayer = NULL; + +#ifdef __WINSCW__ + TParse* fp = new (ELeave) TParse(); + fp->Set(KTMSUnsecureVoIPCall, NULL, NULL); + TFileName fileName(fp->FullName()); + delete fp; + iUnsecureVoIPTonePlayer = TMSRtAudioHdlr::NewL(fileName, + iRtParam.iPriority, iRtParam.iPreference, *this, + EPlayerUnsecureVoIP); +#else + iUnsecureVoIPTonePlayer = TMSRtAudioHdlr::NewSeqL(KTMSUnsecureVoIPCall(), + iRtParam.iPriority, iRtParam.iPreference, *this, + EPlayerUnsecureVoIP); +#endif // __WINSCW__ + + iRtParam.iType = EPlayerUnsecureVoIP; + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateCustomSequencePlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateCustomSequencePlayerL(const TDesC8& +#ifdef __WINSCW__ + /*aSequence*/) +#else + aSequence) +#endif + { + TRACE_PRN_FN_ENT; + + delete iSequencePlayer; + iSequencePlayer = NULL; + +#ifdef __WINSCW__ + TParse* fp = new (ELeave) TParse(); + fp->Set(KTMSBeepSequence, NULL, NULL); + TFileName fileName(fp->FullName()); + delete fp; + iSequencePlayer = TMSRtAudioHdlr::NewL(fileName, iRtParam.iPriority, + iRtParam.iPreference, *this, EPlayerSequence); +#else + iSequencePlayer = TMSRtAudioHdlr::NewSeqL(aSequence, iRtParam.iPriority, + iRtParam.iPreference, *this, EPlayerSequence); +#endif // __WINSCW__ + + iRtParam.iType = EPlayerSequence; + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CreateTTSPlayerL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::CreateTTSPlayerL(const TDesC& aTextToSay) + { + TRACE_PRN_FN_ENT; + + RemoveTTSPlayer(); + TPtrC ttsHeader(KTMSTtsHeader); + HBufC* buf = HBufC::New(aTextToSay.Length() + ttsHeader.Length()); + if (buf) + { + TPtr ptr = buf->Des(); + ptr.Append(ttsHeader); + ptr.Append(aTextToSay); + TRACE_PRN_N1(_L("TMS->CreateTTSPlayerL: Text:[%S]"), &ptr); + TRAPD(err, iTtsPlayer = TMSRtAudioHdlr::NewTtsL(*buf, + KAudioPriorityTextToSpeechCall, KAudioPrefTextToSpeechCall, + *this, EPlayerTts)); + if (err == TMS_RESULT_SUCCESS) + { + iTtsToneToBePlayed = ETrue; + iRtParam.iTextToSay.Set(aTextToSay); + } + } + delete buf; + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::RemoveTTSPlayer +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::RemoveTTSPlayer() + { + TRACE_PRN_FN_ENT; + + delete iTtsPlayer; + iTtsPlayer = NULL; + iTtsToneToBePlayed = EFalse; + iRtParam.iTextToSay.Set(KNullDesC()); + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayRingToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlayRingToneL() + { + TRACE_PRN_FN_ENT; + + // Check active Profile for any changes since Init() + // TODO: To improve perfomrance, instead of polling Profile settings, + // consider subscribing to ProfilEngine P&S keys in CenRep. + LoadActiveProfileSettingsL(); + + switch (iRtParam.iType) + { + case EPlayerAudio: + { + PlayTtsTone(); + PlayAudioRingToneL(); + break; + } + case EPlayerBeepOnce: + BeepOnceL(); + break; + case EPlayerSilent: + PlaySilentToneL(); + break; + case EPlayerUnsecureVoIP: + PlayUnsecureVoIPToneL(); + break; + case EPlayerDefault: + PlayTtsTone(); + PlayDefaultToneL(); + break; + case EPlayerBackup: + PlayBackupToneL(); + break; + case EPlayerSequence: + PlaySequenceToneL(); + break; + default: + break; + } + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayAudioRingToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlayAudioRingToneL() + { + TRACE_PRN_FN_ENT; + + if (!iRtContainer || !CheckAndHandleToneSizeLimit(iRtContainer)) + { + PlayDefaultToneL(); + } + else if (iRtParam.iRingingType == EProfileRingingTypeSilent) + { + PlaySilentToneL(); + } + else if (iRtParam.iRingingType == EProfileRingingTypeBeepOnce) + { + BeepOnceL(); + } + else + { + if (!iAudioPlayer) + { + CreateAudioPlayerL(); + if (!iTimer->IsRunning()) + { + // If InitComplete event doesn't occur within permittable time, + // this will trigger fallback routine. + iTimer->NotifyAfter(KTMSMaxRingingWaiting, *this); + } + } + + // Start playing. + if (!iAudioPlayer) + { + iTimer->CancelNotify(); + PlayDefaultToneL(); + } + else + { + iTonePlayingStatus = EAudioTonePlaying; + iAudioPlayer->Play(ConvertRingingType(iRtParam.iRingingType), + iRtParam.iVolume, iTtsToneToBePlayed); + } + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::BeepOnceL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::BeepOnceL() + { + TRACE_PRN_FN_ENT; + + if (!iBeepOncePlayer) + { + CreateBeepOncePlayerL(); + } + if (iBeepOncePlayer) + { + iTonePlayingStatus = EBeepOnce; + iBeepOncePlayer->Play(TMSRtAudioHdlr::ETypeRingingOnce, + iRtParam.iVolume, EFalse); + } + else + { + PlayDefaultToneL(); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlaySilentToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlaySilentToneL() + { + TRACE_PRN_FN_ENT; + + if (!iSilentPlayer) + { + CreateSilentPlayerL(); + } + if (iSilentPlayer) + { + iTonePlayingStatus = ESilentTonePlaying; + iSilentPlayer->Play(TMSRtAudioHdlr::ETypeRinging, 0, EFalse); + } + else + { + PlayDefaultToneL(); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayUnsecureVoIPToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlayUnsecureVoIPToneL() + { + TRACE_PRN_FN_ENT; + + if (!iUnsecureVoIPTonePlayer) + { + CreateUnsecureVoipPlayerL(); + } + if (iUnsecureVoIPTonePlayer) + { + iTonePlayingStatus = EUnsecureVoIPTonePlaying; + iUnsecureVoIPTonePlayer->Play(TMSRtAudioHdlr::ETypeRingingOnce, + KRTDefaultVolume, EFalse); + } + else + { + PlayDefaultToneL(); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlaySequenceToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlaySequenceToneL() + { + TRACE_PRN_FN_ENT; + + if (iSequencePlayer) + { + iTonePlayingStatus = ESequenceTonePlaying; + iSequencePlayer->Play(ConvertRingingType(iRtParam.iRingingType), + iRtParam.iVolume, EFalse); + } + else + { + PlayDefaultToneL(); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayTtsTone +// Schedule TTS to play, if text has been provided +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlayTtsTone() + { + TRACE_PRN_FN_ENT; + + TInt err = TMS_RESULT_SUCCESS; + + if (iRtParam.iTextToSay.Length() && !iTtsPlayer) + { + TRAP(err, CreateTTSPlayerL(iRtParam.iTextToSay)); + } + if (err == TMS_RESULT_SUCCESS && iTtsPlayer && iTtsToneToBePlayed) + { + iTtsDelayIndex = 0; + iTtsDelaysCount = KTMSTtsDelaysCount; + + // Start TTS timer just before RT + if (!iTtsDelayTimer->IsRunning()) + { + iTtsDelayTimer->NotifyAfter(KTMSTtsDelays[iTtsDelayIndex], + TCallBack(HandleTtsDelayTimeout, this)); + } + iTtsVolume = iRtParam.iVolume; + iTtsRingingType = iRtParam.iRingingType; + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayBackupToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlayBackupToneL() + { + TRACE_PRN_FN_ENT; + + TInt err = TMS_RESULT_SUCCESS; + + if (!iBackupPlayer) + { + TRAP(err, CreateBkpRtPlayerL()); + } + + if (iBackupPlayer && err == TMS_RESULT_SUCCESS) + { + iTonePlayingStatus = EBackupTonePlaying; + iTtsToneToBePlayed = EFalse; + iTTsTimeOutCounter = 0; + iTtsDelayTimer->CancelNotify(); + if (iTtsPlayer) + { + iTtsPlayer->StopPlaying(); + delete iTtsPlayer; + iTtsPlayer = NULL; + } + iBackupPlayer->Play(ConvertRingingType(iRtParam.iRingingType), + iRtParam.iVolume, EFalse); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayDefaultToneL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::PlayDefaultToneL() + { + TRACE_PRN_FN_ENT; + + if (iRtParam.iRingingType == EProfileRingingTypeSilent || + iRtParam.iRingingType == EProfileRingingTypeBeepOnce) + { + return; + } + + if (!iRtContainer) + { + // Default tone does not exist, play backup. + PlayBackupToneL(); + return; + } + + if (!iDefaultPlayer) + { + CreateDefaultRtPlayerL(); + if (!iTimer->IsRunning()) + { + // If InitComplete event doesn't occur within permittable time, + // this will trigger fallback routine. + iTimer->NotifyAfter(KTMSMaxRingingWaiting, *this); + } + } + + // Start playing. + if (!iDefaultPlayer) + { + // Default player not ready, play backup. + iTimer->CancelNotify(); + PlayBackupToneL(); + } + else + { + iTonePlayingStatus = EDefaultTonePlaying; + iDefaultPlayer->Play(ConvertRingingType(iRtParam.iRingingType), + iRtParam.iVolume, iTtsToneToBePlayed); + } + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::StopPlaying +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::StopPlaying() + { + TRACE_PRN_FN_ENT; + + iTtsToneToBePlayed = EFalse; + iTTsTimeOutCounter = 0; + iTtsDelayTimer->CancelNotify(); + if (iTtsPlayer) + { + iTtsPlayer->StopPlaying(); + delete iTtsPlayer; + iTtsPlayer = NULL; + } + iTimer->CancelNotify(); + + switch (iTonePlayingStatus) + { + case EAudioTonePlaying: + if (iAudioPlayer) + { + // Commented out to correct screen jamming after + // REComSession::FinalClose(). Audio player will be stopped + // in its destructor. Fixes EKKI-7WYG2G and JKAN-7XNGQU. + // iAudioPlayer->StopPlaying(); + delete iAudioPlayer; + iAudioPlayer = NULL; + } + break; + case EDefaultTonePlaying: + if (iDefaultPlayer) + { + iDefaultPlayer->StopPlaying(); + delete iDefaultPlayer; + iDefaultPlayer = NULL; + } + break; + case EBeepOnce: + if (iBeepOncePlayer) + { + iBeepOncePlayer->StopPlaying(); + delete iBeepOncePlayer; + iBeepOncePlayer = NULL; + } + break; + case EBackupTonePlaying: + if (iBackupPlayer) + { + iBackupPlayer->StopPlaying(); + } + break; + case ESilentTonePlaying: + if (iSilentPlayer) + { + iSilentPlayer->StopPlaying(); + delete iSilentPlayer; + iSilentPlayer = NULL; + } + break; + case EUnsecureVoIPTonePlaying: + if (iUnsecureVoIPTonePlayer) + { + iUnsecureVoIPTonePlayer->StopPlaying(); + delete iUnsecureVoIPTonePlayer; + iUnsecureVoIPTonePlayer = NULL; + } + break; + case ESequenceTonePlaying: + if (iSequencePlayer) + { + iSequencePlayer->StopPlaying(); + delete iSequencePlayer; + iSequencePlayer = NULL; + } + break; + case EVideoTonePlaying: // video ringing tone + case EPersonalVideoTonePlaying: + case ESilentVideoTonePlaying: + if (iBeepOncePlayer != NULL) + { + iBeepOncePlayer->StopPlaying(); + delete iBeepOncePlayer; + iBeepOncePlayer = NULL; + } + if (iSilentPlayer != NULL) + { + iSilentPlayer->StopPlaying(); + delete iSilentPlayer; + iSilentPlayer = NULL; + } + if (iRtContainer) + { + delete iRtContainer; + iRtContainer = NULL; + } + break; + case EIdle: + // Do nothing here. + return; + default: + break; + } + + iTonePlayingStatus = EIdle; + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::DeinitRingTonePlayer +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::DeinitRingTonePlayer() + { + StopPlaying(); + RemovePlayers(); + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::RemovePlayers +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::RemovePlayers() + { + delete iAudioPlayer; + iAudioPlayer = NULL; + + delete iDefaultPlayer; + iDefaultPlayer = NULL; + + delete iBeepOncePlayer; + iBeepOncePlayer = NULL; + + delete iSilentPlayer; + iSilentPlayer = NULL; + + delete iUnsecureVoIPTonePlayer; + iUnsecureVoIPTonePlayer = NULL; + + delete iSequencePlayer; + iSequencePlayer = NULL; + + delete iTtsPlayer; + iTtsPlayer = NULL; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::DeletePlayer +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::DeletePlayer() + { + switch (iTonePlayingStatus) + { + case EAudioTonePlaying: + DeletePlayerAsync(EPlayerAudio); + iAudioPlayer = NULL; + break; + case EDefaultTonePlaying: + DeletePlayerAsync(EPlayerDefault); + iDefaultPlayer = NULL; + break; + case ESilentTonePlaying: + DeletePlayerAsync(EPlayerSilent); + iSilentPlayer = NULL; + break; + case EUnsecureVoIPTonePlaying: + DeletePlayerAsync(EPlayerUnsecureVoIP); + iUnsecureVoIPTonePlayer = NULL; + break; + case EBeepOnce: + DeletePlayerAsync(EPlayerBeepOnce); + iBeepOncePlayer = NULL; + break; + case ESequenceTonePlaying: + DeletePlayerAsync(EPlayerSequence); + iSequencePlayer = NULL; + break; + case EBackupTonePlaying: + default: + break; + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::DeletePlayerAsync +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::DeletePlayerAsync(TRtPlayerType aPlayer) + { + TRACE_PRN_FN_ENT; + + __ASSERT_DEBUG(aPlayer >= EPlayerFirst && + aPlayer < iAsyncDeletePlayers.Count(), + PANIC(TMS_RESULT_INVALID_ARGUMENT)); + + // Player is deleted in HandleAsyncReq. + + if (iAsyncDeletePlayers[aPlayer]) + { + delete iAsyncDeletePlayers[aPlayer]; + iAsyncDeletePlayers[aPlayer] = NULL; + } + + TMSRtAudioHdlr** players[] = { + &iAudioPlayer, + &iBeepOncePlayer, + &iSilentPlayer, + &iUnsecureVoIPTonePlayer, + &iDefaultPlayer, + &iSequencePlayer, + &iBackupPlayer, + &iTtsPlayer + }; + + __ASSERT_DEBUG(iAsyncDeletePlayers.Count() > aPlayer, + PANIC(TMS_RESULT_ILLEGAL_OPERATION)); + + iAsyncDeletePlayers[aPlayer] = *(players[aPlayer]); + *(players[aPlayer]) = NULL; + iAsyncReq = ETrue; + if (!iAsyncReqAO->IsActive()) + iAsyncReqAO->Start(); //Start async request + + TRACE_PRN_FN_ENT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::HandleError +// From TMSAsyncReqObsrv +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::HandleError(TInt /*aError*/) + { + // TODO: should we kill/restart a/o? + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::HandleAsyncReq +// From TMSAsyncReqObsrv +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::HandleAsyncReq() + { + TRACE_PRN_FN_ENT; + + if (iAsyncReq) + { + for (TInt i = EPlayerFirst; i <= EPlayerLast; i++) + { + delete iAsyncDeletePlayers[i]; + iAsyncDeletePlayers[i] = NULL; + } + } + iAsyncReq = EFalse; + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::HandleTtsDelayTimeout +// ----------------------------------------------------------------------------- +// +TInt TMSRingTonePlayer::HandleTtsDelayTimeout(TAny* object) + { + static_cast (object)->DoHandleTtsDelayTimeout(); + return TMS_RESULT_SUCCESS; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::DoHandleTtsDelayTimeout +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::DoHandleTtsDelayTimeout() + { + TRACE_PRN_FN_ENT; + + TMSRtAudioHdlr* currPlayer = NULL; + currPlayer = GetCurrentlyActiveAudioPlayerWithTTS(); + + if (!currPlayer || !iTtsPlayer) + { + return; + } + + TInt volume(0); + + // Ascending case. TTS player needs to be ascending. + if (iTtsRingingType == EProfileRingingTypeAscending) + { + // Adjust volume for each ascending step + if (!iTTsTimeOutCounter) + { + // Playing caller's name for the first time in ascending mode. + volume = KTtsVolumeMin; + iTtsPlayer->Play(ConvertRingingType(EProfileRingingTypeRingingOnce), + volume, iTtsToneToBePlayed); + } + else + { + // Checks the case that ringingtone is very quiet. Then do not play + // TTS too loud + volume = iTtsVolume < KTtsVolumeMin ? + KTtsVolumeMin : KTtsVolumeAscendingRepeat; + + // We are saying callers name for the second time in ascending mode. + // Say callers name by volume level KTtsVolumeAscendingRepeat and + // decrease current players volume + // to KPlayerVolumeAscendingRepeat. RampTime is zero + currPlayer->SetNewVolumeAndRamptime( + KPlayerVolumeAscendingRepeat, 0); + iTtsPlayer->Play(ConvertRingingType(EProfileRingingTypeRingingOnce), + volume, iTtsToneToBePlayed); + } + } + else //Normal ringing case. + { + currPlayer->SetNewVolumeAndRamptime(iTtsVolume - 5, 0); + iTtsPlayer->Play(ConvertRingingType(EProfileRingingTypeRingingOnce), + iTtsVolume, iTtsToneToBePlayed); + } + + iTTsTimeOutCounter++; + + TRACE_PRN_FN_EXT; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::MuteRingTone +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::MuteRingTone() + { + TMSRtAudioHdlr* activePlayer = ActiveAudioPlayer(); + if (activePlayer != NULL) + { + activePlayer->MutePlaying(); + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::RtAudioHdlrEvent +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::RtAudioHdlrEvent(TInt aEvent, TInt aError, TInt aPlayer) + { + if (aError == TMS_RESULT_SUCCESS) + { + switch (aEvent) + { + case ECmdRingToneOpenComplete: + if (aPlayer != EPlayerBackup && aPlayer != EPlayerTts) + { + HandleRtAudioInitComplete(aEvent, aError, aPlayer); + } + break; + case ECmdRingTonePlayComplete: + HandleRtAudioPlayComplete(aEvent, aError, aPlayer); + break; + default: + //not possible + break; + } + } + else + { + HandleRtAudioError(aEvent, aError, aPlayer); + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::HandleRtAudioError +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::HandleRtAudioError(TInt aEvent, TInt aError, + TInt aPlayer) + { + TRACE_PRN_N1(_L("TMS->HandleRtAudioError [%d]"), aError); + + // Backup player events don't need to be propagated + if (aPlayer == EPlayerBackup) + { + return; + } + if (aPlayer == EPlayerTts && aEvent == ECmdRingTonePlayComplete) + { + // Remove TTS and keep playing RT + DeletePlayerAsync(EPlayerTts); + return; + } + const TBool deleteAll = (aError == KErrServerTerminated); + if (deleteAll) + { + // KErrServerTerminated is considered fatal error - delete all. + for (TInt i = EPlayerFirst; i <= EPlayerLast; i++) + { + DeletePlayerAsync(static_cast (i)); + } + // Recreate backup player + TRAPD(ignore, CreateBkpRtPlayerL()); + if (ignore) ; + } + + iTimer->CancelNotify(); + DoHandlePlayerError(!deleteAll, EFalse); + iRtObserver.RtPlayerEvent(aEvent, aError); + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::HandleRtAudioInitComplete +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::HandleRtAudioInitComplete(TInt aEvent, TInt aError, + TInt aPlayer) + { + if ((iTonePlayingStatus == EAudioTonePlaying && aPlayer == EPlayerAudio) || + (iTonePlayingStatus == EDefaultTonePlaying && + aPlayer == EPlayerDefault)) + { + iTimer->CancelNotify(); + } + else + { + iRtObserver.RtPlayerEvent(aEvent, aError); + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::HandleRtAudioPlayComplete +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::HandleRtAudioPlayComplete(TInt aEvent, TInt aError, + TInt aPlayer) + { + TRACE_PRN_N2(_L("TMS->HandleRtAudioPlayComplete: player=[%d], err=[%d]"), + aPlayer, aError); + + if (aPlayer == EPlayerTts) + { + ResumeTTS(); + return; + } + // RT playback has completed: ring once and TTS is activated + else if (iRtParam.iRingingType == EProfileRingingTypeRingingOnce && + iTtsToneToBePlayed) + { + // Ring once and TTS + if (iTtsDelayIndex < iTtsDelaysCount) + { + ReStartRingTonePlayer(); + return; + } + } + // RT has completed: ringing and TTS is activated. + // We need to restart RT and new TTS iterations are required. + else if (iRtParam.iRingingType == EProfileRingingTypeRinging && + iTtsToneToBePlayed) + { + // Ringing and TTS + if (iTtsDelayIndex == iTtsDelaysCount) + { + // Ringingtype is "Ringing". New TTS iterations are required. + // Need to restart TTS sequence TTS has completed its iterations, + // set index to zero. + iTtsDelayIndex = 0; + if (!iTtsDelayTimer->IsRunning()) + { + // Restart TTS sequence + iTtsDelayTimer->NotifyAfter(KTMSTtsDelays[iTtsDelayIndex], + TCallBack(HandleTtsDelayTimeout, this)); + } + } + + ReStartRingTonePlayer(); + return; + } + + DeletePlayer(); + iTonePlayingStatus = EIdle; + iRtObserver.RtPlayerEvent(aEvent, aError); + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::ResumeTTS +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::ResumeTTS() + { + // TTS playing complete, normal tone player should volume up. + if ((iTtsToneToBePlayed) && (++iTtsDelayIndex < iTtsDelaysCount)) + { + // Resuming after TTS first time + // Caller name is said once. Increase tone player volume. + SolveNewVolumeAndRamptime(ESaidOnce); + + if (!iTtsDelayTimer->IsRunning()) + { + // There are more TTS iterations to be played. + iTtsDelayTimer->NotifyAfter(KTMSTtsDelays[iTtsDelayIndex], + TCallBack(HandleTtsDelayTimeout, this)); + } + } + else + { + // Resuming after TTS second time. + SolveNewVolumeAndRamptime(ESaidTwice); + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::TimerEvent +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::TimerEvent() + { + DoHandlePlayerError(ETrue, ETrue); + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::DoHandlePlayerError +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::DoHandlePlayerError(TBool aDelete, TBool aSync) + { + switch (iTonePlayingStatus) + { + case EAudioTonePlaying: + { + if (aDelete) + { + if (aSync) + { + delete iAudioPlayer; + } + else + { + DeletePlayerAsync(EPlayerAudio); + } + iAudioPlayer = NULL; + } + +#ifdef __WINSCW__ + TRAP_IGNORE(PlayAudioRingToneL()); + iTonePlayingStatus = EDefaultTonePlaying; +#else + TRAP_IGNORE(PlayDefaultToneL()); +#endif //__WINSCW__ + break; + } + case EDefaultTonePlaying: + { + if (aDelete) + { + if (aSync) + { + delete iDefaultPlayer; + } + else + { + DeletePlayerAsync(EPlayerDefault); + } + iDefaultPlayer = NULL; + } + + TRAPD(ignore, PlayBackupToneL()); + if (ignore) ; + break; + } + case ESilentTonePlaying: + case EBeepOnce: + case EBackupTonePlaying: + case EIdle: + default: + break; + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::ConvertRingingType +// ----------------------------------------------------------------------------- +// +TMSRtAudioHdlr::TRingingType TMSRingTonePlayer::ConvertRingingType( + TProfileRingingType aRingingType) + { + TMSRtAudioHdlr::TRingingType ringingType = TMSRtAudioHdlr::ETypeRinging; + switch (aRingingType) + { + case EProfileRingingTypeRinging: + ringingType = TMSRtAudioHdlr::ETypeRinging; + break; + case EProfileRingingTypeAscending: + ringingType = TMSRtAudioHdlr::ETypeAscending; + break; + case EProfileRingingTypeRingingOnce: + ringingType = TMSRtAudioHdlr::ETypeRingingOnce; + break; + default: + break; + } + return ringingType; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::ExtendedSecurity +// ----------------------------------------------------------------------------- +// +TBool TMSRingTonePlayer::ExtendedSecurity() const + { + return iExtSecNeeded; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::SolveNewVolumeAndRamptime +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::SolveNewVolumeAndRamptime(TTtsStatus aStatus) + { + TMSRtAudioHdlr* currPlayer = NULL; + currPlayer = GetCurrentlyActiveAudioPlayerWithTTS(); + if (!currPlayer) + { + return; + } + + TInt ramptime(0); + + // Handle TTS volume. TTS sequence is as follows: + // 3 sec, tone + name + 4 sec, tone + name + the tone until the end. + switch (aStatus) + { + case ESaidOnce: + { + if (iTtsRingingType == EProfileRingingTypeAscending) + { + // The ramptime could be (4)* KTMSTtsAscendingStep but now + // we are setting this to 0 because when caller's name is played + // for the first time: play ringing tone on level 3 for 4 secs. + ramptime = 0; + // Played once ascending + currPlayer->SetNewVolumeAndRamptime( + KPlayerVolumeAscendingRepeat, ramptime); + } + else + { + // Normal ringtone case. Adjust volume back to profile level. + // Played once normal + currPlayer->SetNewVolumeAndRamptime(iTtsVolume, 0); + } + break; + } + case ESaidTwice: + { + if (iTtsRingingType == EProfileRingingTypeAscending) + { + TInt vol = iTtsVolume; + if (vol > KPlayerVolumeAscendingRepeat) + { + vol = vol - KTtsVolumeAscendingDecrease; + } + + // TTS playing complete for the second time. Increase volume. + ramptime = (vol) * KTMSTtsAscendingStep; + // Played twice ascending + currPlayer->SetNewVolumeAndRamptime(iTtsVolume, ramptime); + } + else + { + // Normal ringtone case. Adjust volume back to profile level. + // Played twice normal + currPlayer->SetNewVolumeAndRamptime(iTtsVolume, 0); + } + break; + } + default: + break; + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::PlayerType +// ----------------------------------------------------------------------------- +// +TRtPlayerType TMSRingTonePlayer::PlayerType() const + { + return iRtParam.iType; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::GetCurrentlyActiveAudioPlayerWithTTS +// ----------------------------------------------------------------------------- +// +TMSRtAudioHdlr* TMSRingTonePlayer::GetCurrentlyActiveAudioPlayerWithTTS() + { + TMSRtAudioHdlr* player = NULL; + + if (iAudioPlayer) + { + player = iAudioPlayer; + } + else if (iDefaultPlayer) + { + player = iDefaultPlayer; + } + else if (iBackupPlayer) + { + player = iBackupPlayer; + } + return player; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::ReStartRingTonePlayer +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::ReStartRingTonePlayer() + { + // Find active player which plays along with TTS. + TMSRtAudioHdlr* currPlayer = NULL; + currPlayer = GetCurrentlyActiveAudioPlayerWithTTS(); + if (currPlayer) + { + currPlayer->ReStartPlaying(); + } + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CheckAndHandleToneSizeLimit +// ----------------------------------------------------------------------------- +// +TBool TMSRingTonePlayer::CheckAndHandleToneSizeLimit( + TMSRtContainer* aRingingTone) + { + TBool bValidSize = ETrue; + + // If RT size is too large, will play default tone instead. + if (iToneFileSizeLimitKB) + { + if (CheckToneFileSize(aRingingTone->FileName(), iToneFileSizeLimitKB) + != TMS_RESULT_SUCCESS) + { + bValidSize = EFalse; + } + } + return bValidSize; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::CheckToneFileSize +// ----------------------------------------------------------------------------- +// +TInt TMSRingTonePlayer::CheckToneFileSize(const TDesC& aFile, TInt aSizeLimitKB) + { + // Get file size + TInt size = 0; + TInt error = TMS_RESULT_SUCCESS; + + RFs fs; + error = fs.Connect(); + + if (error == TMS_RESULT_SUCCESS) + { + TEntry entry; + if (TMS_RESULT_SUCCESS == fs.Entry(aFile, entry)) + { + size = entry.iSize; + } + } + fs.Close(); + + aSizeLimitKB *= Kkilo; + if (aSizeLimitKB && size > aSizeLimitKB) + { + error = KErrTooBig; + } + + TRACE_PRN_N1(_L("TMS->CheckToneFileSize: [%d]"), size); + return error; + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::GetMaxToneFileSizeL +// ----------------------------------------------------------------------------- +// +void TMSRingTonePlayer::GetMaxToneFileSizeL(TInt& /*aMaxSizeKB*/) const + {/* + const TInt error = CPhoneCenRepProxy::Instance()->GetInt( + KCRUidProfileEngine, KProEngRingingToneMaxSize, aMaxSizeKB); + + if (error != TMS_RESULT_SUCCESS) + { + aMaxSizeKB = 0; + } + if (aMaxSizeKB < 0) + { + aMaxSizeKB = 0; + } + */ + //TRACE_PRN_N1("TMS->GetMaxToneFileSizeL: [%d]", aMaxSizeKB); + } + +// ----------------------------------------------------------------------------- +// TMSRingTonePlayer::ActiveAudioPlayer +// ----------------------------------------------------------------------------- +// +TMSRtAudioHdlr* TMSRingTonePlayer::ActiveAudioPlayer() + { + TMSRtAudioHdlr* audioHdlr = NULL; + + switch (iTonePlayingStatus) + { + case EAudioTonePlaying: + { + if (iAudioPlayer != NULL) + { + audioHdlr = iAudioPlayer; + } + break; + } + case EDefaultTonePlaying: + { + if (iDefaultPlayer != NULL) + { + audioHdlr = iDefaultPlayer; + } + break; + } + case EBeepOnce: + { + if (iBeepOncePlayer != NULL) + { + audioHdlr = iBeepOncePlayer; + } + break; + } + case ESequenceTonePlaying: + { + if (iSequencePlayer != NULL) + { + audioHdlr = iSequencePlayer; + } + break; + } + case EBackupTonePlaying: + { + if (iBackupPlayer != NULL) + { + audioHdlr = iBackupPlayer; + } + break; + } + case ESilentTonePlaying: + { + if (iSilentPlayer != NULL) + { + audioHdlr = iSilentPlayer; + } + break; + } + case EUnsecureVoIPTonePlaying: + { + if (iUnsecureVoIPTonePlayer != NULL) + { + audioHdlr = iUnsecureVoIPTonePlayer; + } + break; + } + default: + break; + } + + return audioHdlr; + } +