/*

* Copyright (c) 2005-2006 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:  State class for alive states

*

*/

#include "aistatealive.h"

#include "aipluginstatemachine.h"

#include "debug.h"

// ======== MEMBER FUNCTIONS ========

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

// TAiStateAliveActive::TAiStateAliveActive()

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

//

TAiStateAliveActive::TAiStateAliveActive()

    {

    }

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

// TAiStateAliveActive::Enter()

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

//

void TAiStateAliveActive::Enter( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Enter Alive active" );

    const TAiTransitionReason reason( 

            aStateMachine.TranslateReason( aStateChange ) );

    aStateMachine.ChangePluginState( reason, CAiContentPublisher::Resume );                                    

    }

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

// TAiStateAliveActive::HandleEvent()

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

//

TBool TAiStateAliveActive::HandleEvent( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Alive active handles event" );

    switch( aStateChange )

        {

        case ESMAIBacklightOff:

            {

            aStateMachine.SwitchToState( EAiAliveInactive, aStateChange );

            return ETrue;

            }

        default:

            {

            return EFalse;

            }

        }

    }

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

// TAiStateAliveActive::Exit()

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

//

void TAiStateAliveActive::Exit( MAiPluginStateMachine& /*aStateMachine*/,

    TAiStateChanges /*aStateChange*/ )

    {

    __PRINTS( "XAI: Exit alive active" );

    }

// ======== MEMBER FUNCTIONS ========

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

// TAiStateAliveInactive::TAiStateAliveInactive()

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

//

TAiStateAliveInactive::TAiStateAliveInactive()

    {

    }

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

// TAiStateAliveInactive::Enter()

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

//

void TAiStateAliveInactive::Enter( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Enter alive inactive" );

    const TAiTransitionReason reason( 

            aStateMachine.TranslateReason( aStateChange ) );

    aStateMachine.ChangePluginState( reason, CAiContentPublisher::Resume );

    aStateMachine.RestartSuspendTimer();

    }

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

// TAiStateAliveInactive::HandleEvent()

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

//

TBool TAiStateAliveInactive::HandleEvent( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: alive inactive handles event" );

    switch( aStateChange )

        {

        case ESMAIIdleForeground:

        case ESMAIBacklightOn:

            {

            aStateMachine.SwitchToState( EAiAliveActive, aStateChange );

            return ETrue;

            }

        case ESMAIT1Timeout:

            {

            aStateMachine.SwitchToState( EAiSuspended, aStateChange );

            return ETrue;

            }

        default:

            {

            return EFalse;

            }

        }

    }

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

// TAiStateAliveInactive::Exit()

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

//

void TAiStateAliveInactive::Exit( MAiPluginStateMachine& /*aStateMachine*/,

    TAiStateChanges /*aStateChange*/ )

    {

    __PRINTS( "XAI: Exit alive inactive" );

    }

// ======== MEMBER FUNCTIONS ========

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

// TAiStateAliveIncall::TAiStateAliveIncall()

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

//

TAiStateAliveIncall::TAiStateAliveIncall()

    {

    }

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

// TAiStateAliveIncall::Enter()

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

//

void TAiStateAliveIncall::Enter( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Enter alive incall" );

    const TAiTransitionReason reason( 

            aStateMachine.TranslateReason( aStateChange ) );

    aStateMachine.ChangePluginState( reason, CAiContentPublisher::Resume );                                    

    }

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

// TAiStateAliveIncall::HandleEvent()

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

//

TBool TAiStateAliveIncall::HandleEvent( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: alive incall handles event" );

    switch( aStateChange )

        {

        case ESMAINoCall:

            {

            // To alive switch

            aStateMachine.SwitchToState( EAiAlive, aStateChange );

            return ETrue;

            }

        case ESMAIInCall:

            {

            // prevent master state from handling this

            return ETrue;

            }

        default:

            {

            return EFalse;

            }

        }

    }

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

// TAiStateAliveIncall::Exit()

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

//

void TAiStateAliveIncall::Exit( MAiPluginStateMachine& /*aStateMachine*/,

    TAiStateChanges /*aStateChange*/ )

    {

    __PRINTS( "XAI: Exit alive incall" );

    }

// ======== MEMBER FUNCTIONS ========

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

// TAiStateAlive::TAiStateAlive()

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

//

TAiStateAlive::TAiStateAlive( MAiPluginStateMachine& aParentStateMachine )

  : iCurrentState( &iStateAliveInactive ),

    iParentStateMachine( &aParentStateMachine )

    {

    }

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

// TAiStateAlive::SwitchToState()

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

//

void TAiStateAlive::SwitchToState( TAiState aState,

    TAiStateChanges aStateChange )

    {

    switch( aState )

        {

        case EAiAliveInactive:

            {

            iCurrentState = &iStateAliveInactive;

            break;

            }

        case EAiAliveActive:

            {

            iCurrentState = &iStateAliveActive;

            break;

            }

        case EAiAliveIncall:

            {

            iCurrentState = &iStateAliveIncall;

            break;

            }

        default:

            {

            iParentStateMachine->SwitchToState( aState, aStateChange );

            return;

            }

        }   

    iCurrentState->Enter( *this, aStateChange );

    }

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

// TAiStateAlive::StateVariable()

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

//

TBool TAiStateAlive::StateVariable( TAiStateVariable aStateVariable )

    {

    return iParentStateMachine->StateVariable( aStateVariable );

    }

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

// TAiStateAlive::Plugin()

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

//

CAiContentPublisher& TAiStateAlive::Plugin() const

    {

    return iParentStateMachine->Plugin();

    }

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

// TAiStateAlive::TranslateReason()

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

//

TAiTransitionReason TAiStateAlive::TranslateReason( 

    TAiStateChanges aStateChange )

    {

    return iParentStateMachine->TranslateReason( aStateChange );

    }

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

// TAiStateAlive::RestartSuspendTimer()

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

//

void TAiStateAlive::RestartSuspendTimer()

    {

    iParentStateMachine->RestartSuspendTimer();

    }

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

// TAiStateAlive::Enter()

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

//

void TAiStateAlive::Enter( MAiPluginStateMachine& aStateMachine,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Alive switch - enter" );

    if( aStateMachine.StateVariable( ESMAICallStatus ) )

        {

        // If call is ongoing enter alive in call

        iCurrentState = &iStateAliveIncall;

        }

    else if( !aStateMachine.StateVariable( ESMAILightStatus ) )

        {

        // If light is off enter alive inactive

        iCurrentState = &iStateAliveInactive;

        }

    else

        {

        // Otherwise alive active

        iCurrentState = &iStateAliveActive;

        }

    // finally call the Enter() method

    iCurrentState->Enter( *this, aStateChange );

    }

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

// TAiStateAlive::HandleEvent()

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

//

TBool TAiStateAlive::HandleEvent( MAiPluginStateMachine& /*aStateMachine*/,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Alive switch handle event" );

    if( !iCurrentState->HandleEvent( *this, aStateChange ) )

        {

        // Only master state machine handles the "backup/restore on" and

        // screen layout changed cases.

        // Other event are forwarded to the currently active sub state.

        // Other common events may be added here in the future also.

        switch( aStateChange )

            {

            case ESMAIOffLine:

            case ESMAIOnLine:

            case ESMAIKeylockEnabled:

            case ESMAIKeylockDisabled:

            case ESMAIRelayoutScreen:

            case ESMAIIdleForeground:

            case ESMAIIdleBackground:

            case ESMAIPageSwitch:

            case ESMAIGeneralThemeChanged: // fallthrough

                {

                iCurrentState->Enter( *this, aStateChange );

                // Handled the event ok

                break;

                }

            case ESMAIInCall:

                {

                SwitchToState( EAiAliveIncall, aStateChange );

                // Handled the event ok

                break;

                }

            default:

                {

                // Neither current state or master handled this event

                return EFalse;

                }

            }

        }

    // Current state handled the event

    return ETrue;

    }

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

// TAiStateAlive::Exit()

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

//

void TAiStateAlive::Exit( MAiPluginStateMachine& /*aStateMachine*/,

    TAiStateChanges aStateChange )

    {

    __PRINTS( "XAI: Alive switch exit" );

    iCurrentState->Exit( *this, aStateChange );

    }

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

// TAiStateAlive::ChangePluginState()

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

//

void TAiStateAlive::ChangePluginState( TAiTransitionReason aReason,       

    void (CAiContentPublisher::*aStateChangeMethod)(TAiTransitionReason) )

    {

    iParentStateMachine->ChangePluginState( aReason, aStateChangeMethod );

    }

// End of file