/*

* 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 <e32base.h>

#include <f32file.h>

#include <utility.h>

#include <AudioPreference.h>

#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 <data_caging_path_literals.hrh>

#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 >" );

    }