/*

* 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:  Plugin state machine impl

*

*/

#include "aipluginstatemachineimpl.h"

#include "aipluginstatemachine.h"

#include "aipluginlifecycleobserver.h"

#include "aipluginstate.h"

#include "aifwpanic.h"

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

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

// CAiPluginStateMachine::CAiPluginStateMachine()

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

//

CAiPluginStateMachine::CAiPluginStateMachine(

    MAiPluginStateResources& aPluginStateResource,    

    CAiContentPublisher& aPlugin )

      : iAlive( *this ),

        iCurrentState( NULL ),

        iPluginStateResource( aPluginStateResource ),        

        iPlugin( aPlugin )

    {

    }

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

// CAiPluginStateMachine::SwitchToState()

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

//

void CAiPluginStateMachine::SwitchToState( TAiState aState,

    TAiStateChanges aStateChange )

    {

    // Store previous state

    MAiPluginState* previousState( iCurrentState );

    // Determine new current state

    switch( aState )

        {

        case EAiAlive:

            {

            iCurrentState = &iAlive;

            break;

            }

        case EAiSuspended:

            {

            iCurrentState = &iSuspended;

            break;

            }

        case EAiIdle:

            {

            iCurrentState = &iIdle;

            break;

            }

        default:

            {

#ifdef _DEBUG

            AiFwPanic::Panic( AiFwPanic::EAiFwPanic_IllegalPluginStateChange );

#endif

            break;

            }

        }

    if( previousState != iCurrentState )

        {

        if( previousState )

            {

            // Exit the previous state

            previousState->Exit( *this, aStateChange );            

            }

        if( iCurrentState )

            {

            // Enter the new state

            iCurrentState->Enter( *this, aStateChange );                    

            }

        }

    }

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

// CAiPluginStateMachine::StateVariable()

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

//

TBool CAiPluginStateMachine::StateVariable( TAiStateVariable aStateVariable )

    {

    return iPluginStateResource.StateVariable( aStateVariable );

    }

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

// CAiPluginStateMachine::Plugin()

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

//

CAiContentPublisher& CAiPluginStateMachine::Plugin() const

    {

    return iPlugin;

    }

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

// CAiPluginStateMachine::HandleEvent()

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

//

TBool CAiPluginStateMachine::HandleEvent( TAiStateChanges aStateChange )

    {

    // State machine handles some state changes directly.

    switch( aStateChange )

        {

        case ESMAISystemBoot:

            {

            // State machine handles startup event(boot/theme change).

            // Check if backup is ongoing

            if( iPluginStateResource.StateVariable( ESMAIBackupRestoreStatus ) )

                {

                SwitchToState( EAiIdle, aStateChange );

                }

            else

                {

                SwitchToState( EAiAlive, aStateChange );

                }

            break;

            }

        case ESMAIBackupOn:

            {

            // Backup/restore directs straight to idle state.

            SwitchToState( EAiIdle, aStateChange );

            break;

            }

        case ESMAIReportThemeChangeStarted:

        case ESMAISystemShutdown:

            {

            // Shutdown drives directly to idle state.

            ChangePluginState( iPluginStateResource.TranslateReason( aStateChange ),

                               CAiContentPublisher::Stop );

            break;

            }

        case ESMAIOnLine:

            {

            if( !iOnline && iCurrentState )

                {

                iOnline = ETrue;

                return iCurrentState->HandleEvent( *this, aStateChange );

                }                

            break;

            }

        case ESMAIOffLine:

            {

            if( iCurrentState )

                {

                iOnline = EFalse;

                return iCurrentState->HandleEvent( *this, aStateChange );                

                }            

            break;

            }

        default:

            {

            if( ( aStateChange == ESMAIBacklightOn ) &&

                !iPluginStateResource.StateVariable( ESMAIIdleFocusStatus ) )

                {

                // Ignore lights on when on background

                return ETrue;

                }

            if( iCurrentState )

                {

                // Other events are handled by the current set state.

                // Current state determines return value.

                return iCurrentState->HandleEvent( *this, aStateChange );                

                }

            }

        }

    // Return event handled.

    return ETrue;

    }

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

// CAiPluginStateMachine::TranslateReason()

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

//    

TAiTransitionReason CAiPluginStateMachine::TranslateReason( 

    TAiStateChanges aStateChange )

    {

    return iPluginStateResource.TranslateReason( aStateChange );

    }

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

// CAiPluginStateMachine::RestartSuspendTimer()

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

//

void CAiPluginStateMachine::RestartSuspendTimer()

    {

    iPluginStateResource.RestartSuspendTimer();

    }

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

// CAiPluginStateMachine::ChangePluginState()

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

//

void CAiPluginStateMachine::ChangePluginState( TAiTransitionReason aReason,         

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

    {       

	TRAP_IGNORE( ( iPlugin.*aStateChangeMethod)( aReason ) );	

    }

// End of file.