diff -r 24062c24fe38 -r 2a26698d78ba phoneapp/phoneuiview/src/phoneringingtonesrvplayerao.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneapp/phoneuiview/src/phoneringingtonesrvplayerao.cpp Mon Mar 15 12:40:24 2010 +0200 @@ -0,0 +1,1564 @@ +/* +* Copyright (c) 2002-2005,2007 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: Active object of the ringing tone player. +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include + +#include "PhoneUI.pan" +#include "cphoneringingtone.h" +#include "cphoneaudioplayer.h" +#include "cphonetimer.h" +#include "phoneringingtonesrvplayerao.h" +#include "phoneringingtonesrv.h" +#include "phoneconstants.h" +#include "phoneuiviewtrace.h" + +#ifdef __WINS__ +#include +#endif + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::NewL +// ----------------------------------------------------------------------------- +// +CPhoneRingingToneSrvPlayerAO* CPhoneRingingToneSrvPlayerAO::NewL( RFs& aFs ) + { + CPhoneRingingToneSrvPlayerAO* self = + new ( ELeave ) CPhoneRingingToneSrvPlayerAO( aFs ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::CPhoneRingingToneSrvPlayerAO +// ----------------------------------------------------------------------------- +// +CPhoneRingingToneSrvPlayerAO::CPhoneRingingToneSrvPlayerAO( RFs &aFs ) : + CActive( CActive::EPriorityStandard ), + iFs( aFs ), + iAsyncDeletePlayers( EPlayerCount ) + { + CActiveScheduler::Add( this ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConstructL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::ConstructL() + { + for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ ) + { + User::LeaveIfError( + iAsyncDeletePlayers.Append( NULL ) ); + } + + // Construct timer. + iTimer = CPhoneTimer::NewL(); + iTtsDelayTimer = CPhoneTimer::NewL(); + + ConstructPlayers(); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::~CPhoneRingingToneSrvPlayerAO +// ----------------------------------------------------------------------------- +// +CPhoneRingingToneSrvPlayerAO::~CPhoneRingingToneSrvPlayerAO() + { + Cancel(); + + iAsyncDeletePlayers.ResetAndDestroy(); + iAsyncDeletePlayers.Close(); + + CleanupPlayers(); + + delete iTimer; + delete iTtsDelayTimer; + delete iDefaultRingingTone; + delete iAudioVideoRingingTone; + + if ( iClientMessage.Handle() ) + { + iClientMessage.Complete( KErrNone ); + } + } + + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::PlayAudioRingTone +// ----------------------------------------------------------------------------- +// +TBool CPhoneRingingToneSrvPlayerAO::PlayAudioRingTone( + TInt aVolume, + TProfileRingingType aRingingType, + const RMessage2& aMessage ) + { + + TBool messageSaved = EFalse; + iTimer->Cancel(); + + // Release any old client (shouldn't happen) + if ( iClientMessage.Handle() ) + { + iClientMessage.Complete( KErrNone ); + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayAudioRingTone <" ); + PHONEUIVIEW_PRINTF2( + "CPhoneRingingToneSrvPlayerAO::PlayAudioRingTone - aVolume(%d), aRingingType(%d)", + aVolume, + aRingingType ); + + if ( !iAudioVideoRingingTone || + !CheckAndHandleToneSizeLimit( iAudioVideoRingingTone ) ) + { + PlayDefaultTone( aVolume, aRingingType ); + } + else if ( aRingingType == EProfileRingingTypeSilent ) + { + PlaySilentTone(); + } + else if ( aRingingType == EProfileRingingTypeBeepOnce ) + { + BeepOnce( aVolume ); + } + else + { + // Construct player for line 1. + if ( !iAudioPlayer ) + { + iAudioPlayer = ConstructTonePlayer( + *iAudioVideoRingingTone, + EPlayerAudio ); + + if ( !iTimer->IsActive() ) + { + PHONEUIVIEW_PRINT( "RING TONE FAILSAFE TIMER START!!" ); + // Start timer, since the player is constructed. + iTimer->After( KPhoneMaxRingingWaiting, this ); + } + } + + // Start playing. + if ( !iAudioPlayer ) + { + iTimer->Cancel(); + PlayDefaultTone( aVolume, aRingingType ); + } + else + { + PHONEUIVIEW_PRINT( + "CPhoneRingingToneSrvPlayerAO::PlayAudioRingTone - Start playing audio" ); + iVolume = aVolume; + iRingingType = aRingingType; + AddTtsPlaybackIfNeeded( aRingingType ); + iTonePlayingStatus = EAudioTonePlaying; + + // Save the client message which will be completed after init/error/timeout + iClientMessage = aMessage; + messageSaved = ETrue; + + iAudioPlayer->Play( + ConvertRingingType( aRingingType ), + aVolume, + iTtsToneToBePlayed ); + } + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayAudioRingTone >" ); + + return messageSaved; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::BeepOnce +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::BeepOnce( TInt aVolume ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::BeepOnce <" ); + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::BeepOnce - aVolume(%d)", aVolume ); + + if ( !iBeepOncePlayer ) + { + ConstructSequencePlayer( EPlayerBeepOnce ); + } + + if ( iBeepOncePlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::BeepOnce - Play" ); + iTonePlayingStatus = EBeepOnce; + iBeepOncePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, + aVolume, EFalse ); + } + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::BeepOnce >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO,::PlaySilentTone +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::PlaySilentTone() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlaySilentTone <" ); + + if ( !iSilentPlayer ) + { + ConstructSequencePlayer( EPlayerSilent ); + } + + __ASSERT_DEBUG( iSilentPlayer, Panic( EPhoneViewGeneralError ) ); + + if ( iSilentPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlaySilentTone - play" ); + iTonePlayingStatus = ESilentTonePlaying; + iSilentPlayer->Play( CPhoneAudioPlayer::ETypeRinging, 0, EFalse ); + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlaySilentTone >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::PlayUnsecureVoIPTone +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::PlayUnsecureVoIPTone() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayUnsecureVoIPTone <" ); + if ( !iUnsecureVoIPTonePlayer ) + { + ConstructSequencePlayer( EPlayerUnsecureVoIP ); + } + __ASSERT_DEBUG( iUnsecureVoIPTonePlayer, Panic( EPhoneViewGeneralError ) ); + + if ( iUnsecureVoIPTonePlayer ) + { + iTonePlayingStatus = EUnsecureVoIPTonePlaying; + iUnsecureVoIPTonePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, + KPhoneDefaultVolume, EFalse ); + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayUnsecureVoIPTone >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::MuteRingingTone +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::MuteRingingTone() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::MuteRingingTone <" ); + + CPhoneAudioPlayer* activePlayer = ActiveAudioPlayer(); + if ( activePlayer ) + { + activePlayer->MutePlaying(); + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::MuteRingingTone >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::StopPlaying +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::StopPlaying() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::StopPlaying <" ); + + // Complete waiting client just in case + if ( iClientMessage.Handle() ) + { + iClientMessage.Complete( KErrNone ); + } + + iTtsToneToBePlayed = EFalse; + iTTsTimeOutCounter = 0; + iTtsDelayTimer->Cancel(); + if ( iTtsPlayer ) + { + iTtsPlayer->StopPlaying(); + delete iTtsPlayer; + iTtsPlayer = NULL; + } + iTimer->Cancel(); + + switch( iTonePlayingStatus ) + { + case EAudioTonePlaying: + if ( iAudioPlayer ) + { + // Commented stopping out, since with this, the screen is jammed + // when REComSession::FinalClose() is reached in + // CPhoneAudioPlayer's destructor. + // Audio player is stopped anyway 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 EIdle: + break; + default: + Panic( EPhoneViewCaseNotHandled ); + break; + } + + iTonePlayingStatus = EIdle; + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::StopPlaying >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::PlayTtsTone +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::PlayTtsTone( + const TDesC& aTextToSay, + TInt aVolume, + TProfileRingingType aRingingType ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayTtsTone <" ); + PHONEUIVIEW_PRINTF2( + "CPhoneRingingToneSrvPlayerAO::PlayTtsTone - aVolume(%d), aRingingType(%d)", + aVolume, aRingingType ); + + if ( iTtsPlayer ) + { + delete iTtsPlayer; + iTtsPlayer = NULL; + } + + //Set ringingtype for Tts. + iTtsRingingType = aRingingType; + iTtsVolume = aVolume; + + // TTS should be a bit louder, than main component. + // No need to check for overflows, they are handled in SET_PHONE_VOLUME macro. + + TPtrC ttsHeader( KPhoneTtsHeader ); + HBufC* preparedString = + HBufC::New( aTextToSay.Length() + ttsHeader.Length() ); + + if ( !preparedString ) + { + PHONEUIVIEW_PRINTF3( + "CPhoneRingingToneSrvPlayerAO::PlayTtsTone: Couldn't allocate buf %d + %d = %d", + aTextToSay.Length(), ttsHeader.Length(), aTextToSay.Length()+ttsHeader.Length() ); + } + else + { + TPtr pPreparedString = preparedString->Des(); + pPreparedString.Append( ttsHeader ); + pPreparedString.Append( aTextToSay ); + + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::PlayTtsTone - about to say %S", + &pPreparedString ); + + TRAPD( + error, + iTtsPlayer = CPhoneAudioPlayer::NewTtsL( + *preparedString, + KAudioPriorityPhoneCall, + KAudioPrefTextToSpeechCallHardCoded, + *this, + EPlayerTts ) ); + if ( error == KErrNone ) + { + // To be played when default or personal tone will be played + iTtsToneToBePlayed = ETrue; + } + PHONEUIVIEW_PRINTF2( + "CPhoneRingingToneSrvPlayerAO::PlayTtsTone - error(%d), iTtsPhoneToBePlayed(%d)", + error, + iTtsToneToBePlayed ); + + delete preparedString; + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayTtsTone >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerError +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerError( + TPhoneAudioPlayerErrorEvent /*aEvent*/, + TInt aError, + TInt /*aId*/ ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerError <" ); + // This is called from CPhoneAudioPlayer - we do not + // want to delete instances from which this method + // is called. + + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerError: error = %d", aError ); + + const TBool deleteAll = ( aError == KErrServerTerminated ); + + if ( deleteAll ) + { + // KErrServerTerminated is considered as fatal error. So we + // need to delete everything. + + for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ ) + { + DeletePlayerAsync( static_cast< TPlayerId >( i ) ); + } + + // Now all member audio players point to NULL, except + // those players in iAsyncDeletePlayers. Recreate + // players. + + ConstructPlayers(); // Ignore error code. + } + + iTimer->Cancel(); + DoHandlePlayerError( !deleteAll, EFalse ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerInitComplete +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerInitComplete( TInt aId ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerInitComplete <" ); + + // This is called from CPhoneAudioPlayer - we do not + // want to delete instances from which this method + // is called. + + // Complete waiting client + if ( iClientMessage.Handle() ) + { + iClientMessage.Complete( KErrNone ); + } + + if ( iTonePlayingStatus == EAudioTonePlaying && aId == EPlayerAudio || + iTonePlayingStatus == EDefaultTonePlaying && aId == EPlayerDefault ) + { + PHONEUIVIEW_PRINT( "RING TONE FAILSAFE TIMER STOP!!" ); + iTimer->Cancel(); + } + + if ( iTtsToneToBePlayed && ( aId != EPlayerTts ) ) + { + // Start TTS timer just before "normal ringtone component" starts + // playing, i.e. after init completed. + if ( iTtsDelayIndex < iTtsDelaysCount ) + { + if ( !iTtsDelayTimer->IsActive() ) + { + // There are TTS iterations to be played yet. + iTtsDelayTimer->After( + KPhoneTtsDelays[iTtsDelayIndex], + TCallBack( HandleTtsDelayTimeout, this ) ); + } + } + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleAudioPlayerInitComplete >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete( TInt aId ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete <" ); + // This is called from CPhoneAudioPlayer - we do not + // want to delete instances from which this method + // is called. + + // Complete waiting client (shouldn't reach this far, but who knows) + if ( iClientMessage.Handle() ) + { + iClientMessage.Complete( KErrNone ); + } + + PHONEUIVIEW_PRINTF2( + "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - aId(%d), iRingingType(%d)", + aId, + iRingingType ); + + PHONEUIVIEW_PRINTF2( + "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - iTtsToneToBePlayed(%d), iTtsDelayIndex(%d)", + iTtsToneToBePlayed, + iTtsDelayIndex ); + + if ( aId == EPlayerTts ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - resuming after TTS" ); + + // TTS playing complete, normal tone player should volume up. + if ( ( iTtsToneToBePlayed ) && ( ++iTtsDelayIndex < iTtsDelaysCount ) ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - resuming after TTS first time" ); + + //Callers name is said once. increase tone player volume. + SolveNewVolumeAndRamptime( ESaidOnce ); + + if ( !iTtsDelayTimer->IsActive() ) + { + // There are TTS iterations to be played yet. + iTtsDelayTimer->After( KPhoneTtsDelays[iTtsDelayIndex], + TCallBack( HandleTtsDelayTimeout,this ) ); + } + } + else + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - resuming after TTS second time" ); + SolveNewVolumeAndRamptime( ESaidTwice ); + } + + // No further processing. All TTS player-related events are not + // "real" ringtone playing completions. + return; + } + + //Case: RingintonePlayer has completed playing with following set: ring once and + // TTS is activated + else if ( iRingingType == EProfileRingingTypeRingingOnce && + iTtsToneToBePlayed ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - ring once and TTS" ); + if ( iTtsDelayIndex < iTtsDelaysCount ) + { + ReStartRingingTonePlayer(); + //Do not destroy player yet. Return. + return; + } + } + //Case: RingintonePlayer has completed playing with following set: ringing + //and TTS is activated. We need to restart ringintoneplayer and new TTS + //iterations are required. + else if ( iRingingType == EProfileRingingTypeRinging && iTtsToneToBePlayed ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - ringing and TTS" ); + if ( iTtsDelayIndex == iTtsDelaysCount ) + { + //Case: Ringingtype is EProfileRingingTypeRinging. New TTS + //iterations are required. + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - need to restart TTS sequence" ); + //TTS has completed its iterations,set index to zero. + iTtsDelayIndex = 0; + if ( !iTtsDelayTimer->IsActive() ) + { + //Restart TTS sequence + iTtsDelayTimer->After( + KPhoneTtsDelays[iTtsDelayIndex], + TCallBack( HandleTtsDelayTimeout, this ) ); + } + } + + ReStartRingingTonePlayer(); + //Do not destroy player yet. Return + return; + } + + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::HandlePlayingComplete - delete player - iTonePlayingStatus(%d)", + iTonePlayingStatus ); + 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 EBackupTonePlaying: + break; + + default: + Panic( EPhoneViewCaseNotHandled ); + break; + } + + iTonePlayingStatus = EIdle; + } + + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::HandleTimeOutL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::HandleTimeOutL() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleTimeOutL <" ); + + + // Guarding timer for startup has expired + + + PHONEUIVIEW_PRINT( "RING TONE FAILSAFE TIMER TRIGGERED!!" ); + + // Start new audio player synchronously. + DoHandlePlayerError( ETrue, ETrue ); + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleTimeOutL >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::DoHandlePlayerError +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::DoHandlePlayerError( + TBool aDelete, + TBool aSync ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoHandlePlayerError <" ); + + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::DoHandlePlayerError: iTonePlayingStatus = %d", + iTonePlayingStatus ); + + // Complete waiting client + if ( iClientMessage.Handle() ) + { + iClientMessage.Complete( KErrNone ); + } + + switch ( iTonePlayingStatus ) + { + case EAudioTonePlaying: + if ( aDelete ) + { + if ( aSync ) + { + delete iAudioPlayer; + } + else + { + DeletePlayerAsync( EPlayerAudio ); + } + + iAudioPlayer = NULL; + } + +#ifdef __WINS__ + PlayAudioRingTone( iVolume, iRingingType, iClientMessage ); + iTonePlayingStatus = EDefaultTonePlaying; +#else + PlayDefaultTone( iVolume, iRingingType ); +#endif + break; + case EDefaultTonePlaying: + if ( aDelete ) + { + if ( aSync ) + { + delete iDefaultPlayer; + } + else + { + DeletePlayerAsync( EPlayerDefault ); + } + + iDefaultPlayer = NULL; + } + + PlayBackupTone( iVolume, iRingingType ); + break; + case ESilentTonePlaying: + case EBeepOnce: + case EBackupTonePlaying: + break; + default: + break; + } + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoHandlePlayerError >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::PlayDefaultTone +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::PlayDefaultTone( + TInt aVolume, + TProfileRingingType aRingingType ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayDefaultTone()" ); + + if( aRingingType == EProfileRingingTypeSilent || + aRingingType == EProfileRingingTypeBeepOnce ) + { + return; + } + + if ( !iDefaultRingingTone ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayDefaultTone - default tone does not exist, play backup..." ); + PlayBackupTone( aVolume, aRingingType ); + return; + } + + // Construct player. + if ( !iDefaultPlayer ) + { + iDefaultPlayer = ConstructTonePlayer( + *iDefaultRingingTone, + EPlayerDefault ); + if ( !iTimer->IsActive() ) + { + PHONEUIVIEW_PRINT( "RING TONE FAILSAFE TIMER START!!" ); + iTimer->After( KPhoneMaxRingingWaiting, this ); + } + } + + // Start playing. + if ( !iDefaultPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayDefaultTone - player not constructed, play backup..." ); + iTimer->Cancel(); + PlayBackupTone( aVolume, aRingingType ); + } + else + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayDefaultTone - play" ); + iVolume = aVolume; + iRingingType = aRingingType; + iTonePlayingStatus = EDefaultTonePlaying; + iDefaultPlayer->Play( + ConvertRingingType( aRingingType ), aVolume, iTtsToneToBePlayed ); + } + + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::PlayBackupTone +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::PlayBackupTone( + TInt aVolume, + TProfileRingingType aRingingType ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayBackupTone()" ); + __ASSERT_DEBUG( iBackupPlayer, Panic( EPhoneViewGeneralError ) ); + + if ( !iBackupPlayer ) + { + ConstructPlayers(); + } + + if ( iBackupPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::PlayBackupTone - play" ); + iTonePlayingStatus = EBackupTonePlaying; + + // Cease playing text-to-speech, if necessary + iTtsToneToBePlayed = EFalse; + iTTsTimeOutCounter = 0; + iTtsDelayTimer->Cancel(); + if ( iTtsPlayer ) + { + iTtsPlayer->StopPlaying(); + delete iTtsPlayer; + iTtsPlayer = NULL; + } + + iBackupPlayer->Play( + ConvertRingingType( aRingingType ), aVolume, EFalse ); + } + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConstructTonePlayer +// ----------------------------------------------------------------------------- +// +CPhoneAudioPlayer* CPhoneRingingToneSrvPlayerAO::ConstructTonePlayer( + const CPhoneRingingTone& aRingingTone, + TInt aId ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructTonePlayer" ); + return CPhoneAudioPlayer::New( + aRingingTone, + KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, + *this, + aId, + iMdaServer, + aId == EPlayerDefault ? EFalse : iExtSecNeeded ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConvertRingingType +// ----------------------------------------------------------------------------- +// +CPhoneAudioPlayer::TRingingType CPhoneRingingToneSrvPlayerAO::ConvertRingingType( + TProfileRingingType aRingingType ) + { + CPhoneAudioPlayer::TRingingType ringingType = + CPhoneAudioPlayer::ETypeRinging; + switch ( aRingingType ) + { + case EProfileRingingTypeRinging: + ringingType = CPhoneAudioPlayer::ETypeRinging; + break; + + case EProfileRingingTypeAscending: + ringingType = CPhoneAudioPlayer::ETypeAscending; + break; + + case EProfileRingingTypeRingingOnce: + ringingType = CPhoneAudioPlayer::ETypeRingingOnce; + break; + + default: + break; + } + return ringingType; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConstructPlayers +// ----------------------------------------------------------------------------- +// +TInt CPhoneRingingToneSrvPlayerAO::ConstructPlayers() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructPlayers <" ); + TRAPD( err, ConstructPlayersL() ); + + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::ConstructPlayers: err = %d", err ); + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructPlayers >" ); + return err; + } + + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConstructPlayersL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::ConstructPlayersL() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructPlayersL <" ); + if ( !iMdaServer ) + { + iMdaServer = CMdaServer::NewL(); + } + + // Construct Backup player. + if ( !iBackupPlayer ) + { + TFileName defaultSoundFile( KDriveZ ); + defaultSoundFile.Append( KPhoneDefaultSoundFile ); + + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::ConstructPlayersL: construct backup player, path = %S", + &defaultSoundFile ); + iBackupPlayer = CPhoneAudioPlayer::NewL( + defaultSoundFile, + KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, + *this, + EPlayerBackup, + iMdaServer + ); + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructPlayersL >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayer +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayer( TPlayerId aId ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayer" ); + + // Construct players. + TRAPD( err, ConstructSequencePlayerL( aId ) ); + if ( err ) + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayer - err(%d)", err ); + } + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayerL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayerL( TPlayerId aId ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayerL <" ); + + // Construct beep once player + if ( aId == EPlayerBeepOnce ) + { +#ifdef __WINS__ + TParse* fp = new (ELeave) TParse(); + fp->Set( KPhoneBeepOnceSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); + TFileName fileName( fp->FullName() ); + delete fp; + + iBeepOncePlayer = CPhoneAudioPlayer::NewL( + fileName, + KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, + *this, + EPlayerBeepOnce ); +#else + iBeepOncePlayer = CPhoneAudioPlayer::NewSeqL( + KPhoneBeepSequence(), + KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, + *this, + EPlayerBeepOnce ); +#endif // __WINS__ + } + + // Construct Silent Player. + else if ( aId == EPlayerSilent ) + { +#ifdef __WINS__ + TParse* fp = new (ELeave) TParse(); + fp->Set( KPhoneSilentSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); + TFileName fileName( fp->FullName() ); + delete fp; + + iSilentPlayer = CPhoneAudioPlayer::NewL( + fileName, + KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, + *this, + EPlayerSilent ); +#else + iSilentPlayer = CPhoneAudioPlayer::NewSeqL( + KPhoneNoSoundSequence(), + KAudioPriorityPhoneCall, + KAudioPrefIncomingCall, + *this, + EPlayerSilent ); +#endif // __WINS__ + } + // Construct unsecure VoIP tone player. + else if ( aId == EPlayerUnsecureVoIP ) + { +#ifdef __WINS__ + TParse* fp = new (ELeave) TParse(); + fp->Set( KPhoneBeepOnceSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); + TFileName fileName( fp->FullName() ); + delete fp; + + iUnsecureVoIPTonePlayer = CPhoneAudioPlayer::NewL( + fileName, + KAudioPrioritySpecialInformationTone, + KAudioPrefSpecialInformation, + *this, + EPlayerUnsecureVoIP ); +#else + iUnsecureVoIPTonePlayer = CPhoneAudioPlayer::NewSeqL( + KPhoneUnsecureVoIPCall(), + KAudioPrioritySpecialInformationTone, + KAudioPrefSpecialInformation, + *this, + EPlayerUnsecureVoIP ); +#endif // __WINS__ + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ConstructSequencePlayerL >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::CleanupPlayers +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::CleanupPlayers() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::CleanupPlayers <" ); + + delete iAudioPlayer; + iAudioPlayer = NULL; + + delete iDefaultPlayer; + iDefaultPlayer = NULL; + + delete iBeepOncePlayer; + iBeepOncePlayer = NULL; + + delete iSilentPlayer; + iSilentPlayer = NULL; + + delete iUnsecureVoIPTonePlayer; + iUnsecureVoIPTonePlayer = NULL; + + delete iBackupPlayer; + iBackupPlayer = NULL; + + delete iMdaServer; + iMdaServer = NULL; + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::CleanupPlayers >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::DeletePlayerAsync +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::DeletePlayerAsync( TPlayerId aPlayer ) + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::DeletePlayerAsync(%d) <", aPlayer ); + + __ASSERT_DEBUG( aPlayer >= EPlayerFirst && aPlayer < iAsyncDeletePlayers.Count(), + Panic( EPhoneViewInvariant ) ); + + // Player is not deleted here, but in RunL. + Cancel(); + + if ( iAsyncDeletePlayers[ aPlayer ] ) + { + delete iAsyncDeletePlayers[ aPlayer ]; + iAsyncDeletePlayers[ aPlayer ] = NULL; + } + + CPhoneAudioPlayer** players[] = + { + &iAudioPlayer, + &iBeepOncePlayer, + &iSilentPlayer, + &iUnsecureVoIPTonePlayer, + &iDefaultPlayer, + &iBackupPlayer, + &iTtsPlayer + }; + + __ASSERT_DEBUG( iAsyncDeletePlayers.Count() > aPlayer, Panic( EPhoneUtilsIndexOutOfBounds ) ); + + iAsyncDeletePlayers[ aPlayer ] = *(players[ aPlayer ]); + *(players[ aPlayer ]) = NULL; + + iState = EDeletingAudioPlayer; + + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + SetActive(); + + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::DeletePlayerAsync(%d) >", aPlayer ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::RunL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::RunL() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::RunL <" ); + + switch ( iState ) + { + case EDeletingAudioPlayer: + { + for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ ) + { + delete iAsyncDeletePlayers[ i ]; + iAsyncDeletePlayers[ i ] = NULL; + } + } + break; + + case EIdleState: + default: + break; + } // switch iState + + iState = EIdleState; + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::RunL >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::DoCancel +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::DoCancel() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoCancel" ); + // Request is completed immediately before SetActive. + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::HandleTtsDelayTimeout +// ----------------------------------------------------------------------------- +// +TInt CPhoneRingingToneSrvPlayerAO::HandleTtsDelayTimeout( TAny* aObject ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleTtsDelayTimeout <" ); + static_cast( aObject )-> + DoHandleTtsDelayTimeout(); + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::HandleTtsDelayTimeout >" ); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout()" ); + PHONEUIVIEW_PRINTF2( + "CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout - iTtsRingingType(%d), iTTsTimeOutCounter(%d)", + iTtsRingingType, iTTsTimeOutCounter ); + + CPhoneAudioPlayer* currPlayer = GetCurrentlyActiveAudioPlayerWithTTs(); + + if ( !currPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout - null current player" ); + return; + } + TInt volume( 0 ); + //Ascending case. TTs player needs to be ascending. + if ( iTtsRingingType == EProfileRingingTypeAscending ) + { + //Volume needs to be different in different ascending steps + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout - play ascending" ); + if ( !iTTsTimeOutCounter ) + { + //We are saying callers name for the first time in ascending mode. + //Say callers name by volume level KTtsVolumeMin. + 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. + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::DoHandleTtsDelayTimeout - play normal" ); + currPlayer->SetNewVolumeAndRamptime( iTtsVolume-5, 0 ); + iTtsPlayer->Play( + ConvertRingingType( EProfileRingingTypeRingingOnce ), + iTtsVolume, + iTtsToneToBePlayed ); + } + + iTTsTimeOutCounter++; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::AddTtsPlaybackIfNeeded +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::AddTtsPlaybackIfNeeded( + TProfileRingingType /*aRingingType*/ ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::AddTtsPlaybackIfNeeded" ); + if ( iTtsToneToBePlayed ) + { + iTtsDelayIndex = 0; + iTtsDelaysCount = KPhoneTtsDelaysCount; + } + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ExtendedSecurity +// ----------------------------------------------------------------------------- +// +TBool CPhoneRingingToneSrvPlayerAO::ExtendedSecurity() const + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::ExtendedSecurity: %d", iExtSecNeeded ); + return iExtSecNeeded; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime( TTtsStatus aStatus ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime <" ); + + CPhoneAudioPlayer* currPlayer = NULL; + currPlayer = GetCurrentlyActiveAudioPlayerWithTTs(); + if ( !currPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime - null current player" ); + return; + } + TInt ramptime( 0 ); + //Here is handled the cases when Callers name is said. Sequence is: + //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 )* KPhoneTtsAscendingStep but now + //we are setting this to 0 because when Say callers name is said + //for first time: play ringing tone on level 3 for four secs. + ramptime = 0; + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime - said once ascending - ramptime(%d)", + ramptime ); + currPlayer->SetNewVolumeAndRamptime( KPlayerVolumeAscendingRepeat, ramptime ); + } + else + { + //Normal ringingtone case. Adjust volume back to profile level. + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime - said once normal - ramptime(%d)", + ramptime ); + currPlayer->SetNewVolumeAndRamptime( iTtsVolume, 0 ); + } + break; + + case ESaidTwice: + if ( iTtsRingingType == EProfileRingingTypeAscending ) + { + TInt vol = iTtsVolume; + if ( vol > KPlayerVolumeAscendingRepeat ) + { + vol = vol - KTtsVolumeAscendingDecrease; + } + + //TTS playing complete for second time. increase tone player volume. + ramptime = ( vol )*KPhoneTtsAscendingStep; + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime - said twice ascending - ramptime(%d)", + ramptime ); + currPlayer->SetNewVolumeAndRamptime( iTtsVolume, ramptime ); + } + else + { + //Normal ringingtone case. Adjust volume back to profile level. + PHONEUIVIEW_PRINTF( + "CPhoneRingingToneSrvPlayerAO::SolveNewVolumeAndRamptime - said twice normal - ramptime(%d)", + ramptime ); + currPlayer->SetNewVolumeAndRamptime( iTtsVolume, 0 ); + } + break; + + default: + break; + } + } + + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::GetCurrentlyActiveAudioPlayerWithTTs +// ----------------------------------------------------------------------------- +// +CPhoneAudioPlayer* +CPhoneRingingToneSrvPlayerAO::GetCurrentlyActiveAudioPlayerWithTTs() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::GetCurrentlyActiveAudioPlayerWithTTs" ); + + if( iAudioPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - audio player" ); + return iAudioPlayer; + } + else if ( iDefaultPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - default player" ); + return iDefaultPlayer; + } + else if( iBackupPlayer ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - backup player" ); + return iBackupPlayer; + } + else + { + return NULL; + } + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ReStartRingingTonePlayer +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::ReStartRingingTonePlayer() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ReStartRingingTonePlayer <" ); + + //First get currently active player which plays among TTS player. + CPhoneAudioPlayer* currPlayer = NULL; + currPlayer = GetCurrentlyActiveAudioPlayerWithTTs(); + if ( currPlayer ) + { + currPlayer->ReStartPlaying(); + } + + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ReStartRingingTonePlayer >" ); + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::CheckAndHandleToneSizeLimit +// ----------------------------------------------------------------------------- +// +TBool CPhoneRingingToneSrvPlayerAO::CheckAndHandleToneSizeLimit( + CPhoneRingingTone* aRingingTone ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::CheckAndHandleToneSizeLimit" ); + TBool bValidSize = ETrue; + + // If user has somehow managed to get a too large file as ringing tone, + // play default tone instead. + if ( iToneFileSizeLimitKB ) + { + if ( CheckToneFileSize( aRingingTone->FileName(), iToneFileSizeLimitKB) != KErrNone ) + { + bValidSize = EFalse; + } + } + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::CheckAndHandleToneSizeLimit - bValidSize(%d)", bValidSize ); + return bValidSize; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::CheckToneFileSize +// ----------------------------------------------------------------------------- +// +TInt CPhoneRingingToneSrvPlayerAO::CheckToneFileSize( const TDesC& aFile, TInt aSizeLimitKB ) + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::CheckToneFileSize" ); + + // Get file size + TInt size = 0; + TInt error = KErrNone; + + TEntry entry; + if ( KErrNone == iFs.Entry( aFile, entry )) + { + size = entry.iSize; + } + + // Check + aSizeLimitKB *= Kkilo; + if ( aSizeLimitKB && size > aSizeLimitKB ) + { + error = KErrTooBig; + } + + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::CheckToneFileSize: size = %d", size ); + return error; + } + + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::ActiveAudioPlayer +// ----------------------------------------------------------------------------- +// +CPhoneAudioPlayer* CPhoneRingingToneSrvPlayerAO::ActiveAudioPlayer() + { + PHONEUIVIEW_PRINT( "CPhoneRingingToneSrvPlayerAO::ActiveAudioPlayer" ); + + switch( iTonePlayingStatus ) + { + case EAudioTonePlaying: + if ( iAudioPlayer ) + { + return iAudioPlayer; + } + break; + + case EDefaultTonePlaying: + if ( iDefaultPlayer ) + { + return iDefaultPlayer; + } + break; + + case EBeepOnce: + if ( iBeepOncePlayer ) + { + return iBeepOncePlayer; + } + break; + + case EBackupTonePlaying: + if ( iBackupPlayer ) + { + return iBackupPlayer; + } + break; + + case ESilentTonePlaying: + if ( iSilentPlayer ) + { + return iSilentPlayer; + } + break; + + case EUnsecureVoIPTonePlaying: + if ( iUnsecureVoIPTonePlayer ) + { + return iUnsecureVoIPTonePlayer; + } + break; + + default: + break; + } + + return NULL; + } + + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::SetExtendedSecurityNeeded +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::SetExtendedSecurityNeeded( TBool aNeeded ) + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::SetExtendedSecurityNeeded: %d", aNeeded ); + + iExtSecNeeded = aNeeded; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::SetToneFileSizeLimit +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::SetToneFileSizeLimit( TInt aLimit ) + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::SetToneFileSizeLimit: %d", aLimit ); + + iToneFileSizeLimitKB = aLimit; + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::SetRingingToneL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::SetRingingToneL( const TDesC& aFilename ) + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::SetRingingToneL: %S", &aFilename ); + + if ( !iAudioVideoRingingTone ) + { + iAudioVideoRingingTone = CPhoneRingingTone::NewL( aFilename ); + } + else if ( iAudioVideoRingingTone->FileName().Compare( aFilename ) ) + { + iAudioVideoRingingTone->SetFileName( aFilename ); + } + } + +// ----------------------------------------------------------------------------- +// CPhoneRingingToneSrvPlayerAO::SetDefaultRingingToneL +// ----------------------------------------------------------------------------- +// +void CPhoneRingingToneSrvPlayerAO::SetDefaultRingingToneL( const TDesC& aFilename ) + { + PHONEUIVIEW_PRINTF( "CPhoneRingingToneSrvPlayerAO::SetDefaultRingingToneL: %S", &aFilename ); + + if ( !iDefaultRingingTone ) + { + iDefaultRingingTone = CPhoneRingingTone::NewL( aFilename ); + } + else if ( iDefaultRingingTone->FileName().Compare( aFilename ) ) + { + iDefaultRingingTone->SetFileName( aFilename ); + } + } + +// End of File