--- a/mmserv/tms/tmsserver/src/tmsrtplayer.cpp Tue Aug 31 15:43:02 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1712 +0,0 @@
-/*
- * 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 <AudioPreference.h>
-#include <MProEngTones.h>
-#include <MProEngToneSettings.h>
-#include <ProEngFactory.h>
-#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<TMSRingTonePlayer*> (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<TRtPlayerType> (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;
- }
-