diff -r 000000000000 -r 5f000ab63145 phoneapp/phoneuiview/src/cphoneringingtoneplayerao.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneapp/phoneuiview/src/cphoneringingtoneplayerao.cpp	Mon Jan 18 20:18:27 2010 +0200
@@ -0,0 +1,1975 @@
+/*
+* 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:  Ringing tone player.
+*
+*/
+
+
+// INCLUDE FILES
+#include "cphoneringingtoneplayerao.h"
+
+#include <cntdef.h>
+#include <f32file.h>
+#include <featmgr.h>
+#include <utility.h>
+#include <AudioPreference.h>
+#include <data_caging_path_literals.hrh>
+#include <MusicPlayerInternalCRKeys.h>
+#include <ProfileEngineDomainCRKeys.h>
+#include <telephonyvariant.hrh>
+#include <UikonInternalPSKeys.h>
+#include <DRMHelperServerInternalCRKeys.h>
+#include <DRMHelper.h>
+#include <activeidle2domainpskeys.h>
+
+#include "phoneui.pan"
+#include "phoneui.hrh"
+#include "mphoneringingtoneobserver.h"
+#include "cphonetimer.h"
+#include "cphonecenrepproxy.h"
+#include "phoneconstants.h"
+#include "phonelogger.h"
+#include "cphoneringingtone.h"
+#include "tphonecmdparamringtone.h"
+#include "cphonepubsubproxy.h"
+#include "cphonecenrepproxy.h"
+#include "cphonemediatorsender.h"
+
+// CONSTANTS
+
+// Minimum acceptable length of parsed DRM message.
+const TInt KPhoneMinDRMTextLength = 3;
+// Value field of parsed DRM string.
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::NewL
+// -----------------------------------------------------------------------------
+//
+CPhoneRingingTonePlayerAO* CPhoneRingingTonePlayerAO::NewL()
+    {
+    CPhoneRingingTonePlayerAO* self = 
+        new ( ELeave ) CPhoneRingingTonePlayerAO();
+    
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::CPhoneRingingTonePlayerAO
+// -----------------------------------------------------------------------------
+//
+CPhoneRingingTonePlayerAO::CPhoneRingingTonePlayerAO() :
+    CActive( CActive::EPriorityStandard ),
+    iAsyncDeletePlayers( EPlayerCount )
+    {
+    CActiveScheduler::Add( this );
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::ConstructL()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructL()" );
+    
+    for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ )
+        {
+        User::LeaveIfError( 
+            iAsyncDeletePlayers.Append( NULL ) );
+        }
+
+    // Construct timer.
+    iTimer = CPhoneTimer::NewL();
+    iTtsDelayTimer = CPhoneTimer::NewL();
+
+    // Checks if DRM extend security is needed
+    TInt extSecNeeded = KErrNone;
+    TInt err = CPhoneCenRepProxy::Instance()->GetInt(
+        KCRUidMusicPlayerFeatures,
+        KRequireDRMInPlayback,
+        extSecNeeded );
+ 
+    iExtSecNeeded = ( ( err == KErrNone ) && extSecNeeded ) ? ETrue : EFalse;
+    
+    
+    CPhoneCenRepProxy::Instance()->NotifyChangeL(
+        KCRUidDRMHelperServer, 
+        KDRMHelperServerNotificationPassive,
+        this );
+    
+
+    // Check video player configuration.
+    iArbitraryVideoScaling = 
+    CPhoneCenRepProxy::Instance()->IsTelephonyFeatureSupported( 
+            KTelephonyLVFlagArbitraryVideoScaling );
+ 
+    // Construct the default ringing tone
+    TBuf<KMaxFileName> defaultTone;
+    err = CPhoneCenRepProxy::Instance()->GetString(            
+        KCRUidProfileEngine,
+        KProEngDefaultRingingTone,
+        defaultTone );
+
+    if ( err == KErrNone )
+        {
+        iDefaultRingingTone = CPhoneRingingTone::NewL( defaultTone );
+        }
+
+    ConstructPlayers();
+    
+    GetMaxToneFileSizeL( iToneFileSizeLimitKB );
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::~CPhoneRingingTonePlayerAO
+// -----------------------------------------------------------------------------
+//
+CPhoneRingingTonePlayerAO::~CPhoneRingingTonePlayerAO()
+    {
+    Cancel();
+    
+    iAsyncDeletePlayers.ResetAndDestroy();
+    iAsyncDeletePlayers.Close();
+        
+    CleanupPlayers();
+
+    delete iTimer;
+    delete iTtsDelayTimer;
+    delete iDefaultRingingTone;
+    delete iAudioVideoRingingTone;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayRingToneL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayRingToneL( 
+    TPhoneCommandParam* aCommandParam )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayRingToneL()" );
+
+    if ( aCommandParam->ParamId() == 
+        TPhoneCommandParam::EPhoneParamIdRingTone )
+        {
+        TPhoneCmdParamRingTone* ringToneParam = 
+            static_cast<TPhoneCmdParamRingTone*>( aCommandParam );
+
+        const TInt volume = ringToneParam->Volume();
+        TProfileRingingType ringingType = 
+            static_cast<TProfileRingingType>( ringToneParam->RingingType() );
+        
+        if ( !iAudioVideoRingingTone )
+            {
+            iAudioVideoRingingTone = CPhoneRingingTone::NewL(
+                ringToneParam->RingTone() );
+            }
+        else if ( iAudioVideoRingingTone->FileName().Compare(
+            ringToneParam->RingTone() ) ) 
+            {
+            iAudioVideoRingingTone->SetFileName(
+                ringToneParam->RingTone() );
+            }
+        
+        // Caller contact text and image and image has
+        // higher priority than video ringing tone set for caller.
+        if ( iAudioVideoRingingTone->IsVideoRingingTone() &&
+             ringToneParam->IsCallerImage() )
+            {
+            // Play only audio from video ringingtone
+            PlayAudioRingTone(
+                    volume,
+                    ringingType );
+            }
+        else if ( iAudioVideoRingingTone->IsVideoRingingTone() &&
+                !ringToneParam->IsCallerText() )
+            {            
+            // Play video ring tone
+            const TBool ringToneIsPersonal = ringToneParam->Type() ==
+                EPhoneRingTonePersonal;
+            PlayVideoRingingTone( 
+                *iAudioVideoRingingTone, 
+                volume, 
+                ringingType,
+                ringToneIsPersonal );
+            }
+        else
+            {
+            // Play text to speech, if available
+            if ( ringToneParam->TextToSay().Length() )
+                {
+                PlayTtsTone(
+                    ringToneParam->TextToSay(),
+                    volume,
+                    ringingType );
+                }
+            // Play audio ring tone
+            PlayAudioRingTone( 
+                volume, 
+                ringingType );
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayAudioRingTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayAudioRingTone( 
+    TInt aVolume, 
+    TProfileRingingType aRingingType )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayAudioRingTone()" );
+    __PHONELOG2( 
+        EBasic,
+        EPhoneUIView, 
+        "CPhoneRingingTonePlayerAO::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() )
+                {
+                // Start timer, since the player is constructed.
+                iTimer->After( KPhoneMaxRingingWaiting, this );
+                }
+            }
+
+        // Start playing.
+        if ( !iAudioPlayer )
+            {
+            iTimer->Cancel();
+            PlayDefaultTone( aVolume, aRingingType );
+            }
+        else
+            {
+            __PHONELOG( 
+                EBasic, 
+                EPhoneUIView, 
+                "CPhoneRingingTonePlayerAO::PlayAudioRingTone - Start playing audio" );
+            iVolume = aVolume;
+            iRingingType = aRingingType;
+            AddTtsPlaybackIfNeeded( aRingingType );
+            iTonePlayingStatus = EAudioTonePlaying;
+            iAudioPlayer->Play( 
+                ConvertRingingType( aRingingType ),
+                aVolume,
+                iTtsToneToBePlayed );
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::BeepOnce
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::BeepOnce( TInt aVolume )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::BeepOnce()" );
+    __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::BeepOnce - aVolume(%d)",
+        aVolume );
+
+    if ( !iBeepOncePlayer )
+        {
+        ConstructSequencePlayer( EPlayerBeepOnce );
+        }
+
+    if ( iBeepOncePlayer )
+        {
+        __PHONELOG( 
+            EBasic, 
+            EPhoneUIView, 
+            "CPhoneRingingTonePlayerAO::BeepOnce - Play" );
+        iTonePlayingStatus = EBeepOnce;
+        iBeepOncePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, 
+            aVolume, EFalse );        
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlaySilentTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlaySilentTone()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlaySilentTone()" );
+
+    if ( !iSilentPlayer )
+        {
+        ConstructSequencePlayer( EPlayerSilent );
+        }
+
+    __ASSERT_DEBUG( iSilentPlayer, Panic( EPhoneViewGeneralError ) );
+
+    if ( iSilentPlayer )
+        {
+        __PHONELOG( 
+            EBasic, 
+            EPhoneUIView, 
+            "CPhoneRingingTonePlayerAO::PlaySilentTone - play" );
+        iTonePlayingStatus = ESilentTonePlaying;
+        iSilentPlayer->Play( CPhoneAudioPlayer::ETypeRinging, 0, EFalse );        
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone()" );
+    if ( !iUnsecureVoIPTonePlayer )
+        {
+        ConstructSequencePlayer( EPlayerUnsecureVoIP );
+        }
+    __ASSERT_DEBUG( iUnsecureVoIPTonePlayer, Panic( EPhoneViewGeneralError ) );
+
+    if ( iUnsecureVoIPTonePlayer )
+        {
+        iTonePlayingStatus = EUnsecureVoIPTonePlaying;
+        iUnsecureVoIPTonePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce,
+            KPhoneDefaultVolume, EFalse );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer()" );
+    
+    if ( iVideoPlayer && iTonePlayingStatus == EVideoTonePlaying ||
+         iTonePlayingStatus == EPersonalVideoTonePlaying )
+        {
+        // Mute the video audio
+        iVideoPlayer->MuteVideoRingTone();
+        iTonePlayingStatus = ESilentVideoTonePlaying;
+        iVolume = 0;
+        }
+    else
+        {
+        DoMuteRingingTone();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::MuteRingingTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::MuteRingingTone()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::MuteRingingTone()" );
+    
+    if ( iVideoPlayer && iTonePlayingStatus == EVideoTonePlaying ||
+         iTonePlayingStatus == EPersonalVideoTonePlaying )
+        {
+        // Mute the video audio
+        iVideoPlayer->MuteVideoRingTone();
+        iTonePlayingStatus = ESilentVideoTonePlaying;
+        iVolume = 0;
+        }
+    else
+        {
+        StopPlaying();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::StopPlaying
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::StopPlaying()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::StopPlaying()" );
+
+    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 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 ( iVideoPlayer )
+                {
+                iVideoPlayer->StopVideoRingTone();
+                }
+            if ( iAudioVideoRingingTone )
+                {
+                delete iAudioVideoRingingTone;
+                iAudioVideoRingingTone = NULL;    
+                }
+            break;
+        case EIdle:
+            // Do nothing here.
+            return;
+        default:
+            Panic( EPhoneViewCaseNotHandled );
+            break;
+        }
+
+    iTonePlayingStatus = EIdle;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayTtsTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayTtsTone( 
+    const TDesC& aTextToSay, 
+    TInt aVolume,
+    TProfileRingingType aRingingType )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayTtsTone()" );
+    __PHONELOG2( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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 )
+        {
+        TPtr pPreparedString = preparedString->Des();
+        pPreparedString.Append( ttsHeader );
+        pPreparedString.Append( aTextToSay );
+           
+        __PHONELOG1( 
+            EBasic, 
+            EPhoneUIView, 
+            "CPhoneRingingTonePlayerAO::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;
+            }
+        __PHONELOG2(
+            EBasic,
+            EPhoneUIView,
+            "CPhoneRingingTonePlayerAO::PlayTtsTone - error(%d), iTtsPhoneToBePlayed(%d)",
+            error, 
+            iTtsToneToBePlayed );
+
+        delete preparedString;  
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleAudioPlayerError
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleAudioPlayerError( 
+    TPhoneAudioPlayerErrorEvent /*aEvent*/, 
+    TInt aError, 
+    TInt /*aId*/ )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleAudioPlayerError()" );
+    // This is called from CPhoneAudioPlayer - we do not 
+    // want to delete instances from which this method
+    // is called.
+    
+     __PHONELOG1( EBasic, 
+                 EPhoneUIView, 
+                 "CPhoneRingingTonePlayerAO::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 );
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleAudioPlayerInitComplete
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleAudioPlayerInitComplete( TInt aId )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleAudioPlayerInitComplete()" );
+    // This is called from CPhoneAudioPlayer - we do not 
+    // want to delete instances from which this method
+    // is called. 
+
+    if ( iTonePlayingStatus == EAudioTonePlaying && aId == EPlayerAudio ||
+        iTonePlayingStatus == EDefaultTonePlaying && aId == EPlayerDefault )
+        {
+        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 ) );
+                }
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandlePlayingComplete
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandlePlayingComplete( TInt aId )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete()" );
+    // This is called from CPhoneAudioPlayer - we do not 
+    // want to delete instances from which this method
+    // is called. 
+
+    __PHONELOG2(
+        EBasic, 
+        EPhoneUIView,
+        "CPhoneRingingTonePlayerAO::HandlePlayingComplete - aId(%d), iRingingType(%d)",
+        aId,
+        iRingingType );
+    __PHONELOG2(
+        EBasic, 
+        EPhoneUIView,
+        "CPhoneRingingTonePlayerAO::HandlePlayingComplete - iTtsToneToBePlayed(%d), iTtsDelayIndex(%d)",
+        iTtsToneToBePlayed,
+        iTtsDelayIndex );
+
+    if ( aId == EPlayerTts ) 
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - resuming after TTS" );
+
+        // TTS playing complete, normal tone player should volume up.
+        if ( ( iTtsToneToBePlayed ) && ( ++iTtsDelayIndex < iTtsDelaysCount ) )  
+            {
+            __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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
+            {
+            __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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 )   
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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 )
+        {  
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - ringing and TTS" );
+        if ( iTtsDelayIndex == iTtsDelaysCount )
+            {
+            //Case: Ringingtype is EProfileRingingTypeRinging. New TTS
+            //iterations are required.    
+            __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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;  
+        }
+
+    __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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 EVideoTonePlaying:
+        case EPersonalVideoTonePlaying:
+            DeletePlayerAsync( EPlayerBeepOnce );
+            iBeepOncePlayer = NULL;
+            return; // beep once + video
+            
+        case EBackupTonePlaying:
+            break;
+            
+        default:
+            Panic( EPhoneViewCaseNotHandled );
+            break;
+        }
+
+    iTonePlayingStatus = EIdle;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleTimeOutL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleTimeOutL()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleTimeOutL()" );
+
+    // Guarding timer for startup has expired
+    if ( iTonePlayingStatus == EVideoTonePlaying ||
+       iTonePlayingStatus == ESilentVideoTonePlaying ||   
+       iTonePlayingStatus == EPersonalVideoTonePlaying )
+      {
+        iVideoPlayer->CancelVideoRingTone(); // close video ringtone display
+       PlayDefaultTone( iVolume, iRingingType );
+      }
+    else
+      {
+      // Start new audio player synchronously.
+      DoHandlePlayerError( ETrue, ETrue );
+      }			
+		
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::DoHandlePlayerError
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::DoHandlePlayerError(
+    TBool aDelete,
+    TBool aSync )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandlePlayerError()" );
+    switch ( iTonePlayingStatus )
+        {
+        case EAudioTonePlaying:
+            if ( aDelete )
+                {
+                if ( aSync )
+                    {
+                    delete iAudioPlayer;
+                    }
+                else
+                    {
+                    DeletePlayerAsync( EPlayerAudio );
+                    }
+
+                iAudioPlayer = NULL;
+                }
+
+#ifdef __WINS__
+            PlayAudioRingTone( iVolume, iRingingType );
+            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;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayDefaultTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayDefaultTone( 
+    TInt aVolume, 
+    TProfileRingingType aRingingType )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone()" );
+
+    if( aRingingType == EProfileRingingTypeSilent ||
+        aRingingType == EProfileRingingTypeBeepOnce )
+        {
+        return;
+        }
+        
+    if ( !iDefaultRingingTone )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone - default tone does not exist, play backup..." );
+        PlayBackupTone( aVolume, aRingingType );
+        return;    
+        }
+
+    // Construct player.
+    if ( !iDefaultPlayer )
+        {
+        iDefaultPlayer = ConstructTonePlayer( 
+            *iDefaultRingingTone, 
+            EPlayerDefault );
+        if ( !iTimer->IsActive() )
+            {
+            iTimer->After( KPhoneMaxRingingWaiting, this );
+            }
+        }
+
+    // Start playing.
+    if ( !iDefaultPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone - player not constructed, play backup..." );
+        iTimer->Cancel();
+        PlayBackupTone( aVolume, aRingingType );
+        }
+    else
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone - play" );
+        iVolume = aVolume;
+        iRingingType = aRingingType;
+        iTonePlayingStatus = EDefaultTonePlaying;
+        iDefaultPlayer->Play( 
+            ConvertRingingType( aRingingType ), aVolume, iTtsToneToBePlayed );
+        }
+
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayBackupTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayBackupTone( 
+    TInt aVolume, 
+    TProfileRingingType aRingingType )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayBackupTone()" );
+    __ASSERT_DEBUG( iBackupPlayer, Panic( EPhoneViewGeneralError ) );
+
+    if ( !iBackupPlayer )
+        {
+        ConstructPlayers();
+        }
+
+    if ( iBackupPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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 );        
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConstructTonePlayer
+// -----------------------------------------------------------------------------
+//
+CPhoneAudioPlayer* CPhoneRingingTonePlayerAO::ConstructTonePlayer( 
+    const CPhoneRingingTone& aRingingTone,
+    TInt aId )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructTonePlayer()" );
+    return CPhoneAudioPlayer::New(
+        aRingingTone, 
+        KAudioPriorityPhoneCall, 
+        KAudioPrefIncomingCall,
+        *this, 
+        aId,
+        iMdaServer,
+        aId == EPlayerDefault ? EFalse : iExtSecNeeded );
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConvertRingingType
+// -----------------------------------------------------------------------------
+//
+CPhoneAudioPlayer::TRingingType CPhoneRingingTonePlayerAO::ConvertRingingType(
+    TProfileRingingType aRingingType )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConvertRingingType()" );
+
+    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;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConvertVideoRingingType
+// -----------------------------------------------------------------------------
+//
+MPhoneVideoPlayer::TPlayMode CPhoneRingingTonePlayerAO::ConvertVideoRingingType(
+    TProfileRingingType aRingingType )
+    {
+    MPhoneVideoPlayer::TPlayMode playMode;
+        
+    switch ( aRingingType )
+        {
+        case EProfileRingingTypeAscending:
+            playMode = MPhoneVideoPlayer::EPlayAscending;
+            break;
+        case EProfileRingingTypeRingingOnce:
+            playMode = MPhoneVideoPlayer::EPlayOnce;
+            break;
+        case EProfileRingingTypeRinging:
+        default:
+            playMode = MPhoneVideoPlayer::EPlayInLoop;
+            break;
+        }
+    
+    return playMode;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConstructPlayers
+// -----------------------------------------------------------------------------
+//
+TInt CPhoneRingingTonePlayerAO::ConstructPlayers()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructPlayers()" );
+    TRAPD( err, ConstructPlayersL() );
+    return err;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConstructPlayersL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::ConstructPlayersL()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructPlayersL()" );
+
+    // Construct players.
+    if ( !iMdaServer )
+        {
+        iMdaServer = CMdaServer::NewL();
+        }
+
+    // Construct Backup player.
+    if ( !iBackupPlayer )
+        {
+        TFileName defaultSoundFile( KDriveZ );
+        defaultSoundFile.Append( KPhoneDefaultSoundFile );
+        iBackupPlayer = CPhoneAudioPlayer::NewL( 
+            defaultSoundFile,
+            KAudioPriorityPhoneCall,
+            KAudioPrefIncomingCall,
+            *this,
+            EPlayerBackup,
+            iMdaServer 
+            );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConstructSequencePlayer
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::ConstructSequencePlayer( TPlayerId aId )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructSequencePlayer()" );
+
+    // Construct players.
+    TRAPD( err, ConstructSequencePlayerL( aId ) );
+    if ( err )
+        {
+        __PHONELOG1( EBasic, EPhoneUIView, 
+        "CPhoneRingingTonePlayerAO::ConstructSequencePlayer - err(%d)", err );    
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ConstructSequencePlayerL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::ConstructSequencePlayerL( TPlayerId aId )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::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__
+        }        
+    
+    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__
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::CleanupPlayers
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::CleanupPlayers()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::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;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::DeletePlayerAsync
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::DeletePlayerAsync( TPlayerId aPlayer )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DeletePlayerAsync()" );
+    __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();
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::RunL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::RunL()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::RunL()" );
+
+    switch ( iState )
+        {
+        case EDeletingAudioPlayer:
+            {
+            for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ )
+                {
+                delete iAsyncDeletePlayers[ i ];
+                iAsyncDeletePlayers[ i ] = NULL;
+                }
+            }
+            break;
+
+      case EPlayingDefaultVideo:
+            {
+            PlayAudioRingTone( iVolume, iRingingType );
+            }
+            break;
+
+        case EIdleState:  
+        default:
+            break;
+        } // switch iState
+    
+    iState = EIdleState;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::DoCancel
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::DoCancel()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoCancel()" );
+    // Request is completed immediately before SetActive.
+    }
+    
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleTtsDelayTimeout
+// -----------------------------------------------------------------------------
+//
+TInt CPhoneRingingTonePlayerAO::HandleTtsDelayTimeout( TAny* object )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleTtsDelayTimeout()" );
+    static_cast<CPhoneRingingTonePlayerAO*>( object )->
+        DoHandleTtsDelayTimeout();
+    return KErrNone;
+    }
+        
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout()" );
+    __PHONELOG2( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout - iTtsRingingType(%d), iTTsTimeOutCounter(%d)",
+        iTtsRingingType, iTTsTimeOutCounter );
+
+    CPhoneAudioPlayer* currPlayer = NULL;
+    currPlayer = GetCurrentlyActiveAudioPlayerWithTTs();        
+    
+    if ( !currPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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.
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout - play normal" ); 
+        currPlayer->SetNewVolumeAndRamptime( iTtsVolume-5, 0 );                       
+        iTtsPlayer->Play(
+            ConvertRingingType( EProfileRingingTypeRingingOnce ),
+            iTtsVolume,
+            iTtsToneToBePlayed );
+        }
+      
+     iTTsTimeOutCounter++;
+    }
+    
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::AddTtsPlaybackIfNeeded
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::AddTtsPlaybackIfNeeded( 
+        TProfileRingingType /*aRingingType*/ )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::AddTtsPlaybackIfNeeded()" );
+    if ( iTtsToneToBePlayed )   
+        {
+        iTtsDelayIndex = 0;
+        iTtsDelaysCount = KPhoneTtsDelaysCount;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::SetVideoPlayer
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::SetVideoPlayer( 
+    MPhoneVideoPlayer* aVideoPlayer )
+    {
+    iVideoPlayer = aVideoPlayer;    
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayVideoRingingTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayVideoRingingTone( 
+    const CPhoneRingingTone& aRingingTone, 
+    TInt aVolume, 
+    TProfileRingingType aRingingType,
+    TBool aPersonalTone )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayVideoRingingTone()" );
+    
+    __ASSERT_DEBUG( iVideoPlayer, Panic( EPhoneViewGeneralError ) );
+    
+    iVolume = aVolume;
+    iRingingType = aRingingType;
+    TBool startTimer( ETrue );
+    
+     // Extended security check
+    if ( ExtendedSecurity() )
+        {
+        if ( !aRingingTone.IsFileInRom() &&
+             !aRingingTone.IsFileDrmProtected() )
+            {
+            __PHONELOG( EBasic, 
+                        EPhoneUIView, 
+                        "CPhoneRingingTonePlayerAO::HandleVideoPlayerError - PermissionDenied" );
+            PlayDefaultTone( iVolume, iRingingType );
+            return;
+            }
+        __PHONELOG( EBasic, 
+                    EPhoneUIView, 
+                    "CPhoneRingingTonePlayerAO::HandleVideoPlayerError - ExtSecChk ok" );            
+            }
+ 
+    __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayVideoRingingTone - play" );
+    switch( aRingingType )
+        {
+        case EProfileRingingTypeSilent:
+            iVideoPlayer->PlayVideoRingTone( 
+                aRingingTone.FileName(),
+                ConvertVideoRingingType( aRingingType ),
+                0,
+                iArbitraryVideoScaling,
+                this );
+            PlaySilentTone(); // To start vibra, video may fail.
+            iVolume = 0; // for repeat
+            startTimer = EFalse; // no need for fallback
+            break;
+        
+        case EProfileRingingTypeBeepOnce:
+            iVideoPlayer->PlayVideoRingTone( 
+                aRingingTone.FileName(),
+                ConvertVideoRingingType( aRingingType ),
+                0,
+                iArbitraryVideoScaling,
+                this );
+            BeepOnce( iVolume );
+            iVolume = 0; // for repeat
+            startTimer = EFalse; // no need for fallback
+            break;
+        default:
+            iVideoPlayer->PlayVideoRingTone( 
+                aRingingTone.FileName(),
+                ConvertVideoRingingType( aRingingType ),
+                iVolume,
+                iArbitraryVideoScaling,
+                this );
+            break;                
+        }
+
+    if ( aPersonalTone )
+        {
+        iTonePlayingStatus = EPersonalVideoTonePlaying;
+        }
+    else
+        {
+        iTonePlayingStatus = EVideoTonePlaying;
+        }
+
+    if ( startTimer && !iTimer->IsActive() )
+        {
+        // Start timer to guard video opening
+        iTimer->After( KPhoneMaxRingingWaiting, this );
+        }
+    
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleVideoPlayerError
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleVideoPlayerError( 
+    TPhoneVideoPlayerErrorEvent /*aEvent*/,
+    TInt aError )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleVideoPlayerError()" );
+
+    if ( aError )
+        {
+        __PHONELOG1( EBasic, 
+                     EPhoneUIView, 
+                     "CPhoneRingingTonePlayerAO::HandleVideoPlayerError - error (%d)",
+                     aError );        
+        }
+  
+    // cancel guarding timer
+    iTimer->Cancel();
+
+    // to remove video window
+    iVideoPlayer->CancelVideoRingTone();
+
+    if ( iTonePlayingStatus == EPersonalVideoTonePlaying )
+        {
+        // Play default tone (active profile tone).
+        if ( iAudioVideoRingingTone &&
+             !iAudioVideoRingingTone->IsVideoRingingTone() )
+            {
+            PlayAudioRingTone( iVolume, iRingingType );
+            }
+        else // audio/video tone is video
+            {
+            PlayDefaultVideoAsync();
+            }
+        }
+    else
+        {
+        // Play backup tone
+        PlayDefaultTone( iVolume, iRingingType );
+        }
+
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleVideoPlayerInitComplete
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleVideoPlayerInitComplete()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleVideoPlayerInitComplete()" );
+    
+    // cancel guarding timer
+    iTimer->Cancel();
+    
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleVideoPlayerPlayingComplete
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleVideoPlayerPlayingComplete()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleVideoPlayerPlayingComplete()" );
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::PlayDefaultVideoAsync
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::PlayDefaultVideoAsync()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultVideoAsync()" );    
+     
+    Cancel();
+
+    iState = EPlayingDefaultVideo; 
+
+    TRequestStatus* status = &iStatus;
+    User::RequestComplete( status, KErrNone );
+    SetActive();
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ExtendedSecurity
+// -----------------------------------------------------------------------------
+//    
+TBool CPhoneRingingTonePlayerAO::ExtendedSecurity() const
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ExtendedSecurity()" );
+    return iExtSecNeeded;        
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime( TTtsStatus aStatus )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime()" );
+
+    CPhoneAudioPlayer* currPlayer = NULL;
+    currPlayer = GetCurrentlyActiveAudioPlayerWithTTs();
+    if ( !currPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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;
+                __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said once ascending - ramptime(%d)",
+                    ramptime ); 
+                currPlayer->SetNewVolumeAndRamptime( KPlayerVolumeAscendingRepeat, ramptime );
+                }
+            else
+                {
+                 //Normal ringingtone case. Adjust volume back to profile level. 
+                __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::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;
+                __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said twice ascending - ramptime(%d)",
+                    ramptime ); 
+                currPlayer->SetNewVolumeAndRamptime( iTtsVolume, ramptime );
+                }
+            else
+                {
+                 //Normal ringingtone case. Adjust volume back to profile level. 
+                __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said twice normal - ramptime(%d)",
+                    ramptime ); 
+                currPlayer->SetNewVolumeAndRamptime( iTtsVolume, 0 );
+                }
+            break;
+        
+        default:
+            break;
+        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs
+// -----------------------------------------------------------------------------
+//    
+CPhoneAudioPlayer* 
+CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs()
+    {    
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs()" );
+
+    if( iAudioPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - audio player" ); 
+        return iAudioPlayer;         
+        }
+    else if ( iDefaultPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - default player" ); 
+        return iDefaultPlayer;     
+        }
+    else if( iBackupPlayer )
+        {
+        __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - backup player" ); 
+        return iBackupPlayer;
+        }
+    else
+        {
+        return NULL;
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ReStartRingingTonePlayer
+// -----------------------------------------------------------------------------
+//      
+void CPhoneRingingTonePlayerAO::ReStartRingingTonePlayer()
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ReStartRingingTonePlayer()" );
+
+    //First get currently active player which plays among TTS player.
+    CPhoneAudioPlayer* currPlayer = NULL;
+    currPlayer = GetCurrentlyActiveAudioPlayerWithTTs();   
+    if ( currPlayer )
+        {
+        currPlayer->ReStartPlaying();
+        }      
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit
+// -----------------------------------------------------------------------------
+//
+TBool CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit(
+     CPhoneRingingTone* aRingingTone )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::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;
+            }            
+        }
+    __PHONELOG1( 
+        EBasic,
+        EPhoneUIView, 
+        "CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit - bValidSize(%d)",
+        bValidSize);
+        
+    return bValidSize;
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::CheckToneFileSize
+// -----------------------------------------------------------------------------
+//
+TInt CPhoneRingingTonePlayerAO::CheckToneFileSize( const TDesC& aFile, TInt aSizeLimitKB )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::CheckToneFileSize()" );
+    
+    // Get file size
+    TInt size = 0;
+    TInt error = KErrNone;
+    RFs& fs = CCoeEnv::Static()->FsSession();       
+    TEntry entry;
+    if (KErrNone == fs.Entry( aFile, entry ))
+		{
+		size = entry.iSize;
+		}    
+        
+    // Check
+    aSizeLimitKB *= Kkilo;
+    if ( aSizeLimitKB  &&  size > aSizeLimitKB )
+        {
+        error = KErrTooBig;
+        }
+    
+    __PHONELOG1( 
+        EBasic,
+        EPhoneUIView, 
+        "CPhoneRingingTonePlayerAO::CheckToneFileSize - size (%d)",
+        size );    
+    return error;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL( TInt& aMaxSizeKB ) const
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL()" );
+    
+    const TInt error = CPhoneCenRepProxy::Instance()->GetInt( 
+            KCRUidProfileEngine,
+            KProEngRingingToneMaxSize,
+            aMaxSizeKB );
+   
+   	if ( error != KErrNone )
+    	{
+        aMaxSizeKB = 0;
+    	}
+	if ( aMaxSizeKB < 0 )
+	    {
+	     aMaxSizeKB = 0;
+	    }
+  
+    __PHONELOG2( 
+        EBasic,
+        EPhoneUIView, 
+        "CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL - error (%d), aMaxSizeKB(%d)",
+        error,
+        aMaxSizeKB );	    
+    }
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::ActiveAudioPlayer
+// -----------------------------------------------------------------------------
+//
+CPhoneAudioPlayer* CPhoneRingingTonePlayerAO::ActiveAudioPlayer()
+	{
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ActiveAudioPlayer()" );
+
+    switch( iTonePlayingStatus )
+        {
+        case EAudioTonePlaying:
+            if( iAudioPlayer != NULL )
+                {
+				return iAudioPlayer;
+                }
+            break;
+            
+        case EDefaultTonePlaying:
+            if ( iDefaultPlayer != NULL )
+                {
+				return iDefaultPlayer;
+                }
+            break;
+            
+        case EBeepOnce:
+            if( iBeepOncePlayer != NULL )
+                {
+				return iBeepOncePlayer;
+                }
+            break;
+            
+        case EBackupTonePlaying:
+            if( iBackupPlayer != NULL )
+                {
+                return iBackupPlayer;
+                }
+            break;
+            
+        case ESilentTonePlaying:
+            if( iSilentPlayer != NULL )
+                {
+                return iSilentPlayer;
+                }
+            break;
+            
+        case EUnsecureVoIPTonePlaying:
+            if( iUnsecureVoIPTonePlayer != NULL )
+                {
+                return iUnsecureVoIPTonePlayer;
+                }
+            break;
+            
+        case EVideoTonePlaying: // video ringing tone
+        case EPersonalVideoTonePlaying:
+        case ESilentVideoTonePlaying:
+            if ( iBeepOncePlayer != NULL )
+                {
+                return iBeepOncePlayer;                    
+                }    
+            else if ( iSilentPlayer != NULL )
+                {
+                return iSilentPlayer;                    
+                }    
+            break;
+            
+        default:
+            break;
+        }
+
+	return NULL;		
+	}
+
+// -----------------------------------------------------------------------------
+// CPhoneRingingTonePlayerAO::DoMuteRingingTone
+// -----------------------------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::DoMuteRingingTone()
+	{
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoMuteRingingTone()" );
+	
+	switch( iTonePlayingStatus )
+		{
+        case EVideoTonePlaying: // video ringing tone, fall through
+        case EPersonalVideoTonePlaying: // fall through
+        case ESilentVideoTonePlaying:
+            if ( iVideoPlayer != NULL )
+	            {
+                iVideoPlayer->MuteVideoRingTone();
+                return;	            	
+	            }
+	        break;
+	        
+	    default:
+	    	break;
+		}
+	
+	CPhoneAudioPlayer* activePlayer = ActiveAudioPlayer();
+	if( activePlayer != NULL )
+		{
+		activePlayer->MutePlaying();
+		}
+	}
+
+// -----------------------------------------------------------
+// CPhoneRingingTonePlayerAO::HandleCenRepChangeL
+// -----------------------------------------------------------
+//
+void CPhoneRingingTonePlayerAO::HandleCenRepChangeL( 
+    const TUid& aUid,
+    const TUint /*aId*/ )
+    {
+    __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleCenRepChangeL()");
+    
+    if ( aUid == KCRUidDRMHelperServer )
+        {
+        TBuf<256> tempBuf16( KNullDesC );
+        
+        User::LeaveIfError( CPhoneCenRepProxy::Instance()->GetString(
+            KCRUidDRMHelperServer,
+            KDRMHelperServerNotificationPassive,
+            tempBuf16 ) );         
+       
+        const TBool idleIsTopApp = CPhonePubSubProxy::Instance()->Value(
+            KPSUidAiInformation, KActiveIdleState ) == EPSAiForeground;
+       
+        // Quick validity check and    
+        // The first Tuint8 is the times the content has been informed.
+        // Note should not shown until Idle.
+        if ( idleIsTopApp && tempBuf16.Length() >= KPhoneMinDRMTextLength )
+            { 
+            TBuf8<256> tempBuf8;
+            TPtrC8 ptr((TUint8*)tempBuf16.Ptr(), tempBuf16.Size());
+            HBufC8* buf8 = HBufC8::NewLC( 256 );
+            buf8->Des().Copy(ptr);  
+    	    // Extract URI etc. 
+    	    // buf8 format:
+    	    //<TUint8 aTimes><TUint8 aExpirationMark>
+    	    //<TUint8 aPermissionType>
+    	    //<TUint8 aAutomatedContentType><TDesC8 aContentID>
+     	    TInt8 count = (TInt8)(*(buf8->Ptr())); 
+    	    TChar mark = (TChar)(*(buf8->Ptr()+1));
+    	    TInt8 permtype = (TChar)(*(buf8->Ptr()+2));
+    	    TInt8 automcontenttype = (TChar)(*(buf8->Ptr()+3)); 
+    	    TBuf8<256> curi = buf8->Right( buf8->Length()-4);
+    		
+    		if (curi.Ptr()[curi.Size()-1] == 0)
+    		    {
+    		    // The last character in the descriptor is 0, which means
+    		    // that the original 16-bit desc was padded so
+    		    // remove the last char...
+    		    curi.SetLength(curi.Size()-1);
+    		    }
+    		        
+            // Create DRM helper.     
+            CDRMHelper* drmHelper = CDRMHelper::NewLC();            
+            // Show notification.
+            drmHelper->SetAutomatedType( (CDRMHelper::TDRMHelperAutomatedType)automcontenttype );
+            TInt error = drmHelper->CheckRightsAmountL( curi );
+
+            __PHONELOG1( EBasic, EPhoneUIView, 
+                "CPhoneRingingTonePlayerAO::HandleCenRepChangeL > CheckRightsAmountL, error: %d"
+                , error );
+                           
+            CleanupStack::PopAndDestroy( drmHelper ); 
+            CleanupStack::PopAndDestroy( buf8 ); 
+            } 
+        }
+    }
+    
+//  End of File