/*
* 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 <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 &monitor)
  {
  CTsBackstepping* self = CTsBackstepping::NewLC(monitor);
  CleanupStack::Pop(self);
  return self;
  }

/** 
 *  CTsBackstepping::NewLC
 *  two phase constructor
 */
CTsBackstepping* CTsBackstepping::NewLC(MTsWindowGroupsMonitor &monitor)
{ 
  CTsBackstepping* self = new (ELeave) CTsBackstepping(monitor);
  CleanupStack::PushL(self);
  self->ConstructL();
  return self;
}

/** 
 * CTsBackstepping::CTsBackstepping
 * constructor
 */
CTsBackstepping::CTsBackstepping(MTsWindowGroupsMonitor &monitor)
:
CTsWindowGroupsObserver(monitor)
{
}

/** 
 *  CTsBackstepping::~CTsBackstepping
 *  deconstructor
 */
CTsBackstepping::~CTsBackstepping()
{
    delete mFilter;
}

/** 
 *  CTsBackstepping::ConstructL
 *  two phase constructor
 */
void CTsBackstepping::ConstructL ()
{
    BaseConstructL();
    mFilter = CTsBacksteppingFilter::NewL();
}

/** 
 * CTsBackstepping::AnalyseWindowStackL
 * Analyzes window stack and move homescreen to proper position
 */
void CTsBackstepping::HandleWindowGroupChanged(MTsResourceManager &resource, const TArray<RWsSession::TWindowGroupChainInfo> &windowGroups)
{
    TRAP_IGNORE(HandleWindowGroupChangedL(resource, windowGroups));
}

/** 
 * CTsBackstepping::AnalyseWindowStackL
 * Analyzes window stack and move homescreen to proper position
 */
void CTsBackstepping::HandleWindowGroupChangedL(MTsResourceManager &resource,
                                                const TArray<RWsSession::TWindowGroupChainInfo> &windowGroups)
{  
    // calculate the desired position of Homescreen
    const TInt currentHsOffset(homescreenOffsetL(resource, windowGroups));
    TInt optimalOffset(1);
    TInt targetHsOffset(currentHsOffset);
    for (TInt offset(0); offset < currentHsOffset; ++offset) {
        TUid uid = getUidFromWindowGroupL(resource, windowGroups[offset].iId);
        if (TUid::Null() != uid) {
            if (isEmbededApp(windowGroups[offset])) {
                targetHsOffset = parentOffsetL(offset, windowGroups) + 1;
            } else if (!mFilter->isBlocked(uid)) {
                if(offset + 1 < currentHsOffset && 
                        getUidFromWindowGroupL(resource, windowGroups[offset+1].iId) == TUid::Null()) {
                ++optimalOffset;
                }
                targetHsOffset = optimalOffset;
            }
            break;
        } else {
            ++optimalOffset;
        }
    }

    // change windows order if necessary
    if (targetHsOffset != currentHsOffset) {
        const TInt hsWindowGroup(windowGroups[currentHsOffset].iId);
        resource.WsSession().SetWindowGroupOrdinalPosition(hsWindowGroup, targetHsOffset);
    }
    
    // switch Homescreen to Idle state if Homescreen is not in foreground and is in different state
    if (targetHsOffset != 0) {
        TInt hsState(EHomeScreenIdleState);
        User::LeaveIfError(RProperty::Get(KHsCategoryUid, KHsCategoryStateKey, hsState));
        if (hsState != EHomeScreenIdleState) {
            CAfActivityLauncher *activityEnabler = 
                CAfActivityLauncher::NewLC(resource.ApaSession(), 
                                           resource.WsSession());
            activityEnabler->launchActivityL(KHsActivactionUri);
            CleanupStack::PopAndDestroy(activityEnabler);
        }
    }
}

/** 
 * CTsBackstepping::homescreenOffsetL
 */
TInt CTsBackstepping::homescreenOffsetL(MTsResourceManager &resource,
                                        const TArray<RWsSession::TWindowGroupChainInfo> &windowGroups) const 
{
    TInt offset(KErrNotFound);
    for (TInt iter(0);KErrNotFound == offset && iter < windowGroups.Count(); ++iter) {
        if (KHsCategoryUid == getUidFromWindowGroupL(resource, windowGroups[iter].iId)) {
            offset = iter;
        }
    }
    User::LeaveIfError(offset);
    return offset;
}

/** 
 * CTsBackstepping::homescreenOffsetL
 */
TInt CTsBackstepping::parentOffsetL(TInt offset,
                                    const TArray<RWsSession::TWindowGroupChainInfo> &windowGroups) const 
{
    for(TInt iter(offset + 1); iter < windowGroups.Count(); ++iter) {
        if(windowGroups[iter].iId == windowGroups[offset].iParentId) {
            return isEmbededApp(windowGroups[iter]) ? 
                   parentOffsetL(iter, windowGroups) : iter; 
        }
    }
    User::Leave(KErrNotFound);
    return KErrNotFound;
}

/** 
 * CTsBackstepping::isEmbededApp
 */
TBool CTsBackstepping::isEmbededApp(const RWsSession::TWindowGroupChainInfo &windowGroupInfo) const 
{
    return 0 < windowGroupInfo.iParentId;
}

/** 
 * CTsBackstepping::getUidFromWindowGroupL
 */
TUid CTsBackstepping::getUidFromWindowGroupL(MTsResourceManager &resource, TInt windowGroupId) const
{
    TUid retVal(TUid::Null());
    CApaWindowGroupName *windowGroupName = CApaWindowGroupName::NewLC(resource.WsSession());
    windowGroupName->ConstructFromWgIdL(windowGroupId);
    retVal = windowGroupName->AppUid();
    CleanupStack::PopAndDestroy(windowGroupName);
    return retVal;
}

// end of file