/*

* 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

// -----------------------------------------------------------------------------

//