/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Class to handle email sound playing.

*

*/

#include <AudioPreference.h>

#include <MProfileEngine.h>

#include <MProfile.h>

#include <MProfileTones.h>

#include <MProfileExtraTones.h>

#include <TProfileToneSettings.h>

#include <CProfileChangeNotifyHandler.h>

#include <coreapplicationuisdomainpskeys.h>

#include "emailtrace.h"

#include "memailsoundstatecontext.h"

#include "emailsoundstates.h"

#include "fsnotificationhandlertimer.h"

#include "cmailhandlerpluginpanic.h"

// Local constants

static const TInt KToneMinVolume = 0;

static const TInt KToneMaxVolume = 10;

static const TInt KDelayTimerInterval = 60000000; // 60s

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

// Initializes the state machine by setting initial state and creating

// failure state that can be entered at any time in error cases.

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

//

void CEmailSoundState::InitializeL( MEmailSoundStateContext* aContext )

    {

    FUNC_LOG

    TAny* tls = Dll::Tls();

    if ( !tls )

        {

        // prepare failed state so its always available

        CEmailSoundState* failedState = new ( ELeave ) CEmailSoundFailed( *aContext );

        Dll::SetTls( failedState );

        // now enter to initial state, use failed state for obtaining context

        CEmailInitilisingTone::EnterL( failedState );

        }

    }

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

// Exits the state machine and frees memory allocated for states

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

//

void CEmailSoundState::Uninitialize( CEmailSoundState* aCurrentState )

    {

    FUNC_LOG

    if ( aCurrentState )

        {

        // Exit must be called before deleting failedState because it may

        // also be current state.

        aCurrentState->Exit();

        }

    TAny* tls = Dll::Tls();

    if ( tls )

        {

        CEmailSoundState* failedState =

            reinterpret_cast<CEmailSoundState*>( tls );

        delete failedState;

        Dll::SetTls( NULL );

        }

    }

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

// No-op in base class, also enough for some derived classes.

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

//

void CEmailSoundState::ProfileChanged()

    {

    FUNC_LOG

    }

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

// Tone initialization failure always leads to failed state.

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

//

void CEmailSoundState::AudioInitFailed()

    {

    FUNC_LOG

    // enter to failed state.

    StateTransition( EFailed );

    }

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

// Derived classes implement

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

//

void CEmailSoundState::AudioInitCompleted()

    {

    FUNC_LOG

    }

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

// Derived classes implement

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

//

void CEmailSoundState::AudioPlayCompleted()

    {

    FUNC_LOG

    }

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

// Handled in CEmailReadyToPlay state, in most other states ignored.

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

//

void CEmailSoundState::PlayTone()

    {

    FUNC_LOG

    }

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

// Applicable only in playing state

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

//

void CEmailSoundState::StopTone()

    {

    FUNC_LOG

    }

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

// Tries to create audio player or activas failed state if error occurs

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

//

TBool CEmailSoundState::TryStartToneInitialization()

    {

    FUNC_LOG

    TRAPD( err, iContext.RecreateAudioPlayerL() );

    if ( err )

        {

        StateTransition( EFailed );

        }

    return ( err == KErrNone );

    }

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

// Stores as current state in owner of the state machine.

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

//

void CEmailSoundState::BaseEnter()

    {

    FUNC_LOG

    iContext.SetState( this );

    }

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

// State transition to requested state or failed state if attempt doesn't

// succeed.

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

//

void CEmailSoundState::StateTransition( const TSoundState aState )

    {

    FUNC_LOG

    TRAPD( err,

        {

        switch ( aState )

            {

            case EInit:

                CEmailInitilisingTone::EnterL( this );

                break;

            case EReady:

                CEmailReadyToPlay::EnterL( this );

                break;

            case EPlaying:

                CEmailPlayingTone::EnterL( this );

                break;

            case EPendingPlay:

                CEmailPendingPlay::EnterL( this );

                break;

            case EPendingInit:

                CEmailPendingInit::EnterL( this );

                break;

            case EDelay:

                CEmailTimerDelay::EnterL( this );

                break;

            case EFailed:

            default:

                // to failed state

                /* CodeScanner warning ignored because CS does not regognize

                 * TRAP being used */

                User::Leave( KErrArgument ); // codescanner::leave

                break;

            }

        } );

    if ( err != KErrNone )

        {

        CEmailSoundFailed::Enter( this );

        }

    // exit old state

    Exit();

    }

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

// For most states destructor call is fine.

// See also CEmailSoundFailed::Exit()

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

//

void CEmailSoundState::Exit()

    {

    FUNC_LOG

    delete this;

    }

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

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

//

MEmailSoundStateContext& CEmailSoundState::Context() const

    {

    FUNC_LOG

    return iContext;

    }

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

//

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

//

CEmailSoundState::~CEmailSoundState()

    {

    FUNC_LOG

    }

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

// c++ constructor

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

//

CEmailSoundState::CEmailSoundState(

    MEmailSoundStateContext& aContext ) :

    iContext( aContext )

    {

    FUNC_LOG

    }

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

// c++ constructor

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

//

CEmailInitilisingTone::CEmailInitilisingTone(

    MEmailSoundStateContext& aContext ) :

    CEmailSoundState( aContext )

    {

    FUNC_LOG

    }

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

// Need to cancel and restart tone initialization

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

//

void CEmailInitilisingTone::ProfileChanged()

    {

    FUNC_LOG

    TryStartToneInitialization();

    }

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

//

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

//

void CEmailInitilisingTone::AudioInitCompleted()

    {

    FUNC_LOG

    StateTransition( EReady );

    }

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

//

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

//

void CEmailInitilisingTone::PlayTone()

    {

    FUNC_LOG

    // not ready yet, postpone playing

    StateTransition( EPendingPlay );

    }

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

//

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

//

void CEmailInitilisingTone::DoEnterL()

    {

    FUNC_LOG

    iContext.RecreateAudioPlayerL();

    CEmailSoundState::BaseEnter();

    }

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

//

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

//

void CEmailInitilisingTone::EnterL( CEmailSoundState* aPreviousState )

    {

    FUNC_LOG

    CEmailInitilisingTone* state = new ( ELeave )

        CEmailInitilisingTone( aPreviousState->Context() );

    CleanupStack::PushL( state );

    state->DoEnterL();

    CleanupStack::Pop();

    }

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

// c++ constructor

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

//

CEmailReadyToPlay::CEmailReadyToPlay( MEmailSoundStateContext& aContext )

 : CEmailSoundState( aContext )

    {

    FUNC_LOG

    }

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

// New profile may have different tone, initialize it.

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

//

void CEmailReadyToPlay::ProfileChanged()

    {

    FUNC_LOG

    StateTransition( EInit );

    }

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

//

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

//

void CEmailReadyToPlay::PlayTone()

    {

    FUNC_LOG

    StateTransition( EPlaying );

    }

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

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

//

void CEmailReadyToPlay::DoEnterL()

    {

    FUNC_LOG

    CEmailSoundState::BaseEnter();

    }

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

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

//

void CEmailReadyToPlay::EnterL(

    CEmailSoundState* aPreviousState )

    {

    FUNC_LOG

    CEmailReadyToPlay* state = new ( ELeave ) CEmailReadyToPlay(

        aPreviousState->Context() );

    CleanupStack::PushL( state );

    state->DoEnterL();

    CleanupStack::Pop();

    }

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

// c++ constructor

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

//

CEmailSoundFailed::CEmailSoundFailed( MEmailSoundStateContext& aContext )

 : CEmailSoundState( aContext )

    {

    FUNC_LOG

    }

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

// Something has gone wrong earlier, now try recovery (re-init).

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

//

void CEmailSoundFailed::ProfileChanged()

    {

    FUNC_LOG

    // try re-initialization

    StateTransition( EInit );

    }

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

// Something has gone wrong earlier, now try recovery (re-init + play ).

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

//

void CEmailSoundFailed::PlayTone()

    {

    FUNC_LOG

    // kick off tone re-creation again

    if ( TryStartToneInitialization() )

        {

        StateTransition( EPendingPlay );

        }

    }

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

// Set failed state as current state.

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

//

void CEmailSoundFailed::DoEnter()

    {

    FUNC_LOG

    CEmailSoundState::BaseEnter();

    }

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

// Failed state is preserved until plugin shutdown, therefore base class Exit()

// is overridden and explicit destruction for this class is done in

// CEmailSoundState::Uninitialize.

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

//

void CEmailSoundFailed::Exit()

    {

    FUNC_LOG

    }

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

// Obtain failed state from TLS and set it as current state.

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

//

void CEmailSoundFailed::Enter( CEmailSoundState* /*aPreviousState*/ )

    {

    FUNC_LOG

    TAny* tls = Dll::Tls();

    __ASSERT_ALWAYS( tls, Panic( ECmailHandlerPluginPanicNoFailedState ) );

    CEmailSoundFailed* failedState = reinterpret_cast<CEmailSoundFailed*>( tls );

    failedState->DoEnter();

    }

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

// c++ constructor

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

//

CEmailPlayingTone::CEmailPlayingTone( MEmailSoundStateContext& aContext )

 : CEmailSoundState( aContext )

    {

    FUNC_LOG

    }

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

// When playing completes, recreate tone because new profile may have

// different one.

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

//

void CEmailPlayingTone::ProfileChanged()

    {

    FUNC_LOG

    StateTransition( EPendingInit );

    }

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

// Proceed to delay state.

// Existing player instance owned by context is preserved.

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

//

void CEmailPlayingTone::AudioPlayCompleted()

    {

    FUNC_LOG

    // Tell sysap that tone playing has stopped

    RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsMessageToneQuit, ECoreAppUIsStopTonePlaying );

    StateTransition( EDelay );

    }

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

// Stop tone and proceed to delay state.

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

//

void CEmailPlayingTone::StopTone()

    {

    FUNC_LOG

    CMdaAudioPlayerUtility* player = iContext.AudioPlayer();

    // should never be null in this state

    __ASSERT_ALWAYS( player, Panic( ECmailHandlerPluginPanicNullAudioPlayer ) );

    player->Stop();

    // Tell sysap that tone playing has stopped

    RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsMessageToneQuit, ECoreAppUIsStopTonePlaying );

    StateTransition( EDelay );

    }

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

// Starts playing of already initialized tone.

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

//

void CEmailPlayingTone::EnterL( CEmailSoundState* aPreviousState )

    {

    FUNC_LOG

    CEmailPlayingTone* state = new ( ELeave ) CEmailPlayingTone(

        aPreviousState->Context() );

    CleanupStack::PushL( state );

    state->DoEnterL();

    CleanupStack::Pop();

    }

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

// Playes 'new email' tone.

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

//

void CEmailPlayingTone::DoEnterL()

    {

    FUNC_LOG

    CMdaAudioPlayerUtility* player = iContext.AudioPlayer();

    // should never be null in this state

    __ASSERT_ALWAYS( player, Panic( ECmailHandlerPluginPanicNullAudioPlayer ) );

    MProfile* profile = iContext.ProfileEngine().ActiveProfileL(); // owned

    const TInt profileVolume =

        profile->ProfileTones().ToneSettings().iRingingVolume;

    TInt volume = Max( KToneMinVolume, Min( profileVolume, KToneMaxVolume ) );

    profile->Release();

    profile = NULL;

    // scale with player but only if volume is greater than zero