/*
* Copyright (c) 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:  Engine for BS Engine
 *
*/


#include <apgtask.h>
#include <apgwgnam.h>
#include <eikenv.h>
#include <e32base.h>

#include "bsengineglobals.h"
#include "bsdebug.h"
#include "bsengine.h"
#include "bsapplicationinfo.h"
#include "bsconfiguration.h"

// CONSTANTS
const TInt KSecondTaskIndex( 1);

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

// -----------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CBSEngine::CBSEngine()
    {
    iEnv = CEikonEnv::Static( );
    swap = EFalse;
    wasPressed = EFalse;
    }

// -----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CBSEngine::ConstructL()
    {
    DEBUG(("Create Engine"));
    iConfiguration = CBSConfiguration::NewL( );
    }

// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
//
CBSEngine::~CBSEngine()
    {
    DEBUG(("~CBSEngine"));
    iAppsStack.ResetAndDestroy( );
    iFocusHistory.Close( );

    delete iConfiguration;
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBSEngine* CBSEngine::NewL()
    {
    CBSEngine* self = CBSEngine::NewLC( );
    CleanupStack::Pop( self ) ;
    return self;
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBSEngine* CBSEngine::NewLC()
    {
    CBSEngine* self = new ( ELeave ) CBSEngine();
    CleanupStack::PushL( self );
    self->ConstructL( ) ;
    return self;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CBSEngine::ApplicationKeyWasPressed()
    {
    wasPressed = ETrue;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CBSEngine::HandleFocusChangeL( const TUid& aApp )
    {
    DEBUG(("-> HandleFocusChangeL(0x%X)", aApp.iUid ));
    // check if application is not in ignored list
    if ( iConfiguration->IsIgnored( aApp ) )
        {
        DEBUG(("\tIgnore the event - application in ignored list"));
        return;
        }

    TInt fsCount = iFocusHistory.Count( );
    if ( fsCount > 0 && iFocusHistory[fsCount - 1] == aApp.iUid )
        {
        DEBUG(("\tIgnore the event - application already on top"));
        swap = EFalse;
        wasPressed = EFalse;
        return;
        }

    // check if we should not reset back stepping stack
    if ( iConfiguration->IsReset( aApp ) )
        {
        swap = EFalse;
        wasPressed = EFalse;
        ResetHistory( );
        }

    // check if we should reset if application was started tru 
    RArray<TInt>& thuApps = iConfiguration->ResetIfThruList( );

    for ( TInt i = 0; i < thuApps.Count( ); i++ )
        {
        // position of application - i.e. fast swap
        if ( aApp.iUid == thuApps[i] )
            {
            //mark that there is a fast swap or dialog
            swap = ETrue;
            return;
            }
        else
            {
            if ( swap )
                {
                swap = EFalse;
                TInt currentApp = aApp.iUid;
                TInt pos = iFocusHistory.Count( ) - 1;
                if ( pos >= 0 )
                    {
                    TInt prevApp = iFocusHistory[pos];
                    if ( currentApp != prevApp && wasPressed )
                        {
                        //we are here as the result of the fast swap
                        ResetHistory( );
                        iFocusHistory.AppendL( thuApps[i] );
                        wasPressed = EFalse;
                        }
                    }
                }
            }
        }
    // add application to focus history list, 
    iFocusHistory.AppendL( aApp.iUid );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TInt CBSEngine::HandleActivationEventL( const TUid& aApp,
    const TDesC8& aState, TBool aItem )
    {
    DEBUG(("-> HandleActivationEventL(0x%X, %S, 0x%X)",
                    aApp.iUid, &aState, aItem));
    TInt result(EBSEngineCommandWasNotConsumed);

#ifdef _DEBUG    
    // check from which application it was started 
    for ( TInt i = 0; i< iFocusHistory.Count( ); i++ )
        {
        DEBUG(("\tiFocusHistory[%d] = %X)", i, iFocusHistory[i]));
        }
#endif        

    // is it the same application - i.e. internal state change - ignore       
    CBSApplicationInfo* last(NULL);
    if ( iAppsStack.Count( ) )
        last = iAppsStack[iAppsStack.Count() - 1];

    if ( last && last->AppUid( ) == aApp )
        {
        DEBUG(("\tIgnore the event, application is already on stack"));
        }
    else if ( aItem ) // store only item events
        {
        CBSApplicationInfo* newApp = CBSApplicationInfo::NewLC();
        newApp->SetPrevAppUid( FindPreviousApp( aApp ) );
        newApp->SetAppUid( aApp );
        newApp->SetItemStateL( aState );

        DEBUG(("\tAdd to BS stack app:0x%X, state:%S, prevapp:0x%X)",
                        newApp->AppUid().iUid,
                        &newApp->ItemState(),
                        newApp->PrevAppUid().iUid));
        iAppsStack.AppendL( newApp );
        CleanupStack::Pop( newApp );
        result = EBSEngineCommandWasConsumed;
        }

    return result;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TInt CBSEngine::HandleBackEventL( const TUid& aApp, const TDesC8& aState,
    TBool aCheckOnly )
    {
    DEBUG(("-> HandleBackEventL(0x%X, %S, 0x%X )",
                    aApp.iUid, &aState, aCheckOnly ));
    TInt result(EBSEngineCommandWasNotConsumed);
    // get last application at stack
    CBSApplicationInfo* info(NULL);
    if ( iAppsStack.Count( ) )
        {
        info = iAppsStack[iAppsStack.Count() - 1];

        DEBUG(("\tcheck UIDs (0x%X-0x%X)", aApp.iUid, info->AppUid() ));
        DEBUG(("\tcheck states (%S-%S)", &aState, &info->ItemState()));
        if ( info && info->AppUid( ) == aApp && info->ItemState().Compare( aState ) == 0 )
            {
            DEBUG(("\tcheck prev app, if BS to be ignored = %d)",
                            iConfiguration->IsIgnoredIfStartedFrom( info->PrevAppUid() ) ));

            // check what application activated the application in question 
            if ( !iConfiguration->IsIgnoredIfStartedFrom( info->PrevAppUid( ) ) )
                {
                // find the task which is directly below the current one
                // in window group Z-order hierarchy
                TApaTaskList taskList(iEnv->WsSession( ) );
                // current task is in "0" position, next one is "1"
                // NOTE: FindByPos doesn't return hidden tasks
                TApaTask lowerTask = taskList.FindByPos( KSecondTaskIndex );
                CApaWindowGroupName* apaWGName = CApaWindowGroupName::NewLC(
                    iEnv->WsSession( ), lowerTask.WgId( ) );
                TUid lowerTaskUid = apaWGName->AppUid( );
                CleanupStack::PopAndDestroy( apaWGName );

                DEBUG(("\tcheck task below (0x%X-0x%X)",
                                lowerTaskUid.iUid, info->PrevAppUid().iUid));
                // if the lower task is the one that activated the current one
                // send the current one to background.
                // the condition is false if i.e. the previous active task
                // has been closed or sent to background (no explicit
                // activation of the current task occured)
                if ( lowerTaskUid == info->PrevAppUid( ) )
                    {
                    if ( !aCheckOnly )
                        {
                        SendToBackground( aApp );
                        // remove history for the application    
                        RemoveAppRecord( aApp );
                        }
                    result = EBSEngineCommandWasConsumed;
                    }
                }
            }
        }
    return result;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CBSEngine::SendToBackground( const TUid& aApp )
    {
    DEBUG(("-> SendToBackgroundL(0x%X)", aApp.iUid ));

    TApaTaskList taskList(iEnv->WsSession( ));

    TApaTask task = taskList.FindApp( aApp );
    if ( task.Exists( ) )
        {
        // Request window server to send application to background
        task.SendToBackground( );
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//    
TUid CBSEngine::FindPreviousApp( const TUid& aApp )
    {
    TUid result(TUid::Null( ));

    for ( TInt i = iFocusHistory.Count( ) - 1; i >= 0; i-- )
        {
        if ( iFocusHistory[i] != aApp.iUid )
            {
            result = TUid::Uid( iFocusHistory[i] );
            break;
            }
        }

    return result;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CBSEngine::RemoveAppRecord( const TUid& aApp )
    {
    DEBUG(("-> RemoveRecord(0x%X)", aApp.iUid ));

    for ( TInt i = iAppsStack.Count( ) - 1; i >= 0; i-- )
        {
        CBSApplicationInfo* info = iAppsStack[i];
        if ( info->AppUid( ) == aApp )
            {
            DEBUG(("\tRemove item - [%d]", i));
            iAppsStack.Remove( i );
            delete info;
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CBSEngine::ResetHistory()
    {
    DEBUG(("-> ResetHistory"));
    iAppsStack.ResetAndDestroy( );
    iFocusHistory.Reset( );
    }

// End of File