/*

* 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:

*

*/

#include "tsbackstepping.h"

#include <w32std.h>// key event

#include <apgwgnam.h>// for CApaWindowGroupName

#include <apgtask.h>

#include <coedef.h>

#include <e32property.h>

#include <e32debug.h>

#include <homescreendomainpskeys.h>

#include <afactivitylauncher.h>

#include "tsbacksteppingfilter.h"

_LIT(KHsActivactionUri, "appto://20022F35?activityname=HsIdleView&activityinbackground=true");

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

/** 

 *  CTsBackstepping::NewL

 *  two phase constructor

 */

CTsBackstepping* CTsBackstepping::NewL( MTsWindowGroupsMonitor& aMonitor )

    {

    CTsBackstepping* self = CTsBackstepping::NewLC( aMonitor );

    CleanupStack::Pop( self );

    return self;

    }

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

/** 

 *  CTsBackstepping::NewLC

 *  two phase constructor

 */

CTsBackstepping* CTsBackstepping::NewLC( MTsWindowGroupsMonitor& aMonitor )

    { 

    CTsBackstepping* self = new (ELeave) CTsBackstepping( aMonitor );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

/** 

 * CTsBackstepping::CTsBackstepping

 * constructor

 */

CTsBackstepping::CTsBackstepping( MTsWindowGroupsMonitor &aMonitor )

:

CTsWindowGroupsObserver( aMonitor )

    {

    }

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

/** 

 *  CTsBackstepping::~CTsBackstepping

 *  deconstructor

 */

CTsBackstepping::~CTsBackstepping()

    {

    delete iFilter;

    }

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

/** 

 *  CTsBackstepping::ConstructL

 *  two phase constructor

 */

void CTsBackstepping::ConstructL ()

    {

    BaseConstructL();

    iFilter = CTsBacksteppingFilter::NewL();

    }

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

/** 

 * CTsBackstepping::AnalyseWindowStackL

 * Analyzes window stack and move homescreen to proper position

 */

void CTsBackstepping::HandleWindowGroupChanged( 

               MTsResourceManager &aResource, 

               const TArray<RWsSession::TWindowGroupChainInfo> &aWindowGroups )

    {

    RDebug::Print(_L("[Backstepping] started"));

    TRAP_IGNORE( HandleWindowGroupChangedL( aResource, aWindowGroups ) );

    RDebug::Print(_L("[Backstepping] finished"));

    }

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

/** 

 * CTsBackstepping::AnalyseWindowStackL

 * Analyzes window stack and move homescreen to proper position

 */

void CTsBackstepping::HandleWindowGroupChangedL( 

                MTsResourceManager& aResource,

                const TArray<RWsSession::TWindowGroupChainInfo>& aWindowGroups )

    {

    // calculate the desired position of Homescreen

    const TInt currentHsOffset( HomescreenOffsetL( aResource, aWindowGroups ) );

    TInt optimalOffset(1);

    TInt targetHsOffset(currentHsOffset);

    for( TInt offset(0); offset < currentHsOffset; ++offset ) 

        {

        TUid uid = GetUidFromWindowGroupL( aResource, 

                                           aWindowGroups[offset].iId );

        RDebug::Print(_L("[Backstepping] application: %d"), uid.iUid);

        if( TUid::Null() != uid )

            {

            if( IsEmbededApp( aWindowGroups[offset] ) )

                {

                targetHsOffset = ParentOffsetL( offset, aWindowGroups ) + 1;

                } 

            else if (!iFilter->isBlocked(uid))

                {

                if(offset + 1 < currentHsOffset && 

                   GetUidFromWindowGroupL( aResource, aWindowGroups[offset+1].iId) == TUid::Null() ) 

                    {

                    ++optimalOffset;

                    }

                targetHsOffset = optimalOffset;

                }

            break;

            } 

        else

            {

            ++optimalOffset;

            }

        }

    // switch Homescreen to Idle state if Homescreen is not in foreground and is in different state

    if( 0 != targetHsOffset)

        {

        TInt hsState( EHomeScreenIdleState );

        User::LeaveIfError(RProperty::Get( KHsCategoryUid, 

                                           KHsCategoryStateKey, 

                                           hsState ) );

        if(!(hsState & EHomeScreenWidgetViewActive ) )

            {

            RDebug::Print(_L("[Backstepping] about to switch HS activity"));

            CAfActivityLauncher *activityEnabler = 

                CAfActivityLauncher::NewLC( aResource.ApaSession(), 

                                            aResource.WsSession() );

            activityEnabler->launchActivityL( KHsActivactionUri );

            CleanupStack::PopAndDestroy( activityEnabler );

            }

        }

    // change windows order if necessary

    if(targetHsOffset != currentHsOffset)

        {

        RDebug::Print(_L("[Backstepping] about to change window groups order"));

        const TInt hsWindowGroup( aWindowGroups[currentHsOffset].iId );

        aResource.WsSession().SetWindowGroupOrdinalPosition( hsWindowGroup, 

                                                             targetHsOffset );

        }

    }

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

/** 

 * CTsBackstepping::HomescreenOffsetL

 */

TInt CTsBackstepping::HomescreenOffsetL( 

        MTsResourceManager& aResource,

        const TArray<RWsSession::TWindowGroupChainInfo>& aWindowGroups ) const 

    {

    TInt offset( KErrNotFound );

    for( TInt iter(0); KErrNotFound == offset && iter < aWindowGroups.Count(); ++iter )

        {

        if( KHsCategoryUid == GetUidFromWindowGroupL( aResource, aWindowGroups[iter].iId ) )

            {

            offset = iter;

            }

        }

    User::LeaveIfError( offset );

    return offset;

    }

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

/** 

 * CTsBackstepping::ParentOffsetL

 */

TInt CTsBackstepping::ParentOffsetL( 

        TInt aOffset,

        const TArray<RWsSession::TWindowGroupChainInfo>& aWindowGroups )const 

    {

    for( TInt iter(aOffset + 1); iter < aWindowGroups.Count(); ++iter )

        {

        if(aWindowGroups[iter].iId == aWindowGroups[aOffset].iParentId)

            {

            return IsEmbededApp( aWindowGroups[iter] ) ? 

                   ParentOffsetL( iter, aWindowGroups ) : iter; 

            }

        }

    User::Leave( KErrNotFound) ;

    return KErrNotFound;

    }

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

/** 

 * CTsBackstepping::IsEmbededApp

 */

TBool CTsBackstepping::IsEmbededApp( 

            const RWsSession::TWindowGroupChainInfo &aWindowGroupInfo ) const 

    {

    return 0 < aWindowGroupInfo.iParentId;

    }

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

/** 

 * CTsBackstepping::GetUidFromWindowGroupL

 */

TUid CTsBackstepping::GetUidFromWindowGroupL( MTsResourceManager &aResource, 

                                              TInt aWindowGroupId ) const

    {

    TUid retVal(TUid::Null());

    CApaWindowGroupName *windowGroupName = 

            CApaWindowGroupName::NewLC( aResource.WsSession() );

    windowGroupName->ConstructFromWgIdL( aWindowGroupId );

    retVal = windowGroupName->AppUid();

    CleanupStack::PopAndDestroy( windowGroupName );

    return retVal;

    }

// end of file