/*

* Copyright (c) 2008 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:   AppUi class

*

*/

#include <apgtask.h>

#include <AknDoc.h>

#include "alf/alfappui.h"

#include "alf/alfappserver.h"

#include <uiacceltk/HuiEnv.h>

#include <aknenv.h>

#include <AknsConstants.h>

#include <uiacceltk/HuiSkin.h>

#include <uiacceltk/HuiDisplay.h>

#include <uiacceltk/HuiControl.h>

#include <uiacceltk/HuiControlGroup.h>

#include <uiacceltk/HuiEvent.h>

#include <uiacceltk/HuiDeckLayout.h>

#include <uiacceltk/HuiImageVisual.h>

#include <uiacceltk/HuiTransformation.h>

#include <uiacceltk/HuiBorderBrush.h>

#include <uiacceltk/HuiUtil.h>

#include <uiacceltk/HuiTextVisual.h>

#include <uiacceltk/HuiGradientBrush.h>

#include <uiacceltk/HuiImageBrush.h>

#include <uiacceltk/HuiRoster.h>

#ifdef ALF_USE_CANVAS

#include <uiacceltk/HuiCanvasVisual.h>

#endif

#include "alflogger.h"

#include "alf/alfappsrvsessionbase.h"

#include "alfsrvresourcemanager.h"

#include "alfsrvsettingshandler.h"

#include <uiacceltk/HuiTextureManager.h>

#include "alfsrvtexturemanager.h"

#include "alfstreamerserver.h"

#include "alfshareddisplaycoecontrol.h"

#include "alfbridge.h"

#include "alfstreamerconsts.h"

#include "alfscreen.h"

#include <akntranseffect.h>

#include "alfwindowmanager.h"

#include "alfwindowstructs.h"

#include <e32property.h>

#include "HuiFxEffect.h"

#include <akntransitionutils.h>

#include <alf/AlfTransEffectPlugin.h>

#include "alfwindowdata.h"

#include "huieffectable.h"

#include <akntranseffect.h>

#include "HuiRenderPlugin.h"

#include "huicanvasgc.h"

#include "huicanvasrenderbuffer.h"

#include "alfeffectutils.h"

#include "alfrenderstageutils.h" // for KAlfPSUidSynchronizer & KAlfPSKeySynchronizer

#include "alfdrawerinternal.h"

#ifdef HUI_DEBUG_TRACK_DRAWING

#include <alfcommanddebug.h>

#endif

#ifdef _ALF_FXLOGGING

#include <alfcommanddebug.h>

#endif

#ifdef SYMBIAN_BUILD_GCE

#include <bautils.h>

#endif

const TInt KVisualTransformationStepRotate    = 0;

const TReal32 KAlfVisualDefaultOpacity = 1.0f;

//const TReal32 KAlfVisualDefaultOpacity = 0.5f;

const TInt KEffectCleanupDelayInMs = 10;

const TInt KPreventingCollisionOfIdsInSynchDrawRequests = 35;

const TInt KRequestFrameSynchForComposition = -1; // bogus

const TInt KAlfFSTaskSwapperAppStart = 1507;

_LIT8(KAlfWindowGroupContainerControlTag, "WGROUP");

#define USE_APPLICATION_ENDFULLSCREEN_TIMEOUT

// This debug option shows window groups in a grid

//#define ALF_DEBUG_VISUALIZE_WINDOWGROUP_ORDER

// Timeout for manual refresh

const TInt KAlfManualRefreshTimeout = 35000;

_LIT_SECURITY_POLICY_PASS(KAlwaysPass);

const TUid KPSSysCategory = { KUidSystemCategoryValue };

const TUint32 KAlfPSKeyHSVisible = 0x2002EA91;

const TInt KFadeAction = 6000;

// IsLayoutSwitchReady heuristic constants:

// Duration to wait that visual display rects are fully inside fullscreen rect. 

// 1 unit = 50ms.

const TInt KAlfCheckVisualDisplayRect = 15;

// Duration to wait that visual has drawing inside screen area.

const TInt KAlfCheckVisualDrawRect = 15;

// Duration to wait that visual has drawing that covers the whole display rect.

const TInt KAlfCheckVisualDrawingComplete = 20;

// Duration to wait that visual has some drawing (not necessarily complete).

const TInt KAlfCheckVisualDrawingNotEmpty = 28;

// Duration to wait that fullscreen is covered by visual drawing.

const TInt KAlfCheckFullscreenCoveredByVisualDrawing = 50;

// Duration to wait if coverage is modified by multiple control groups.

// This may indicate that topmost application hasn't yet had time to update

// its layout properly.

const TInt KAlfCheckCoverageFromMultipleGroups = 20;

NONSHARABLE_CLASS( TAlfBridgeDrawerWrapper ) : public MAlfDrawerScreenInterface

    {

public:

    TAlfBridgeDrawerWrapper(CAlfBridge& aBridge);

    TInt GetSizeAndRotation(TSize& aSize, TInt& aRotation);

    TInt ReadPixels(CFbsBitmap* aBitmap);

private:

    CAlfBridge& iBridge;

    };

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

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

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

// 

CAlfBridge* CAlfBridge::NewL( CAlfStreamerBridge** aHost, CHuiEnv* aEnv )

    {

    CAlfBridge* self = new (ELeave) CAlfBridge( aHost );

    CleanupStack::PushL( self );

    self->ConstructL( aEnv );

    CleanupStack::Pop( self );

    return self;

    }

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

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

// 

void CAlfBridge::ProvideBitmapL(TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& aMaskBitmap)

    {

    aBitmap = iHack;

    aMaskBitmap = iDummyMask;

    };

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

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

// 

CAlfBridge::CAlfBridge(CAlfStreamerBridge** aHost)

    : iHost(aHost), iCurrentMemoryLevel(EHuiMemoryLevelNormal)

	{

	}

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

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

// 

CAlfBridge::~CAlfBridge()

	{

    iTempRegion2.Close();

    iAlfNativeClientsWgIds.Close();

	delete iOrphanStorage;

	delete iFadeEffectFile;

	iWindowHashArray.Close();

	for( TInt i = 0; i< iAlfRegisteredEffects.Count(); i++ )

	    {

	    delete iAlfRegisteredEffects[i].iEffectFile;

	    }

	iAlfRegisteredEffects.Close();

    delete iEffectEndTimer;

    iDeadControlGroups.Close();

    iEffectWindowGroups.Close();

    iWindowChainsArray.Close();

    delete iFSFxData;

    delete iFSFXDataPart2;

    if (iActivated)

        {

        iBridgerClient.Close();        

        }

#ifdef HUI_DEBUG_TRACK_DRAWING

    delete iCommandDebug;

#endif

    delete iCursorTimer;

    delete iLayoutSwitchEffectCoordinator;

    delete iManualRefreshTimer;

	}

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

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

// 

void CAlfBridge::ConstructL(CHuiEnv* aEnv)

    {

    iHuiEnv = aEnv;

    iIdForEAlfDSSynchronizeOp = 0;

    iIdForLayoutSwitchFrameSync = iIdForEAlfDSSynchronizeOp - KPreventingCollisionOfIdsInSynchDrawRequests;

#ifdef SYMBIAN_BUILD_GCE

    iPrintFPS = EFalse;

#ifndef __WINSCW__

    _LIT(KRDSupport, "c:\\resource\\errrd" );

    RFs& fs = CHuiStatic::FsSession();

    if (fs.Handle() && BaflUtils::FileExists( fs, KRDSupport ))

        {

        iPrintFPS = ETrue;

        }

#endif

#endif //SYMBIAN_BUILD_GCE

    iEffectEndTimer = CAlfEffectEndTimer::NewL( *this );

    iWindowHashArray.ReserveL( 500 );

    iAlfRegisteredEffects.ReserveL(10);

#ifdef HUI_DEBUG_TRACK_DRAWING

    iCommandDebug = CAlfCommandDebug::NewL();

#endif

    iLayoutSwitchEffectCoordinator = new (ELeave) CAlfLayoutSwitchEffectCoordinator(*this);

    iAlfSecureId = RThread().SecureId();

	// Create control for the orphaned windows, which control group id deleted before them

    iOrphanStorage = new (ELeave) CHuiControl(*iHuiEnv);

    iOrphanStorage->ConstructL();

    RegisterFadeEffectL();

    iManualRefreshTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    RProperty::Define( KPSSysCategory, KAlfPSKeyHSVisible, RProperty::EInt, KAlwaysPass, KAlwaysPass );

    RProperty::Set( KPSSysCategory, KAlfPSKeyHSVisible, 0 );

    }

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

//  RegisterFadeEffectL

//

//  Note, If theme DOES NOT register its own fade effect, another hardcoded fade 

//  effect will be used instead. For example, if theme effects are turned off, 

//  a fade that does not belong to the theme may be in use.

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

void CAlfBridge::RegisterFadeEffectL()

    {

    // TODO: RND, REMOVE MMC DRIVE-F, WHEN NOT REQUIRED FOR TESTING

#ifdef USE_ALTERNATIVE_EFFECTS_FROM_MMC

    _LIT(KDrivePrefence,"FZC"); 

#else

    _LIT(KDrivePrefence,"Z");

#endif

    // Force register fade effect. Try first MMC, then ROM.

    CHuiFxEngine* engine = iHuiEnv->EffectsEngine();

    RFs& fs = CHuiStatic::FsSession();

    if (fs.Handle() && engine)

        {

        _LIT(KFadeEffectPath, ":\\resource\\effects\\fade_effect.fxml");

        TBufC<4> drives(KDrivePrefence);

        HBufC* effectFullName = HBufC::NewLC(KFadeEffectPath().Length() + 1);

        for(TInt i=0; i< drives.Length(); i++)

            {

            effectFullName->Des().Copy(drives.Mid(i,1));

            effectFullName->Des().Append(KFadeEffectPath);

            if (BaflUtils::FileExists( fs, *effectFullName ))

                {

                DoRegisterEffectL(*effectFullName, KFadeAction);

                break;

                }

            }

        CleanupStack::PopAndDestroy(effectFullName);

        DoSetCachedFadeEffectL();

        }

    }

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

// DoSetCachedFadeEffectL

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

// 

void CAlfBridge::DoSetCachedFadeEffectL()

    {

    for (TInt i = 0; i < iAlfRegisteredEffects.Count(); i++)

        {

        //KFadeAction = 6000, indicating the action corroposnds to fading

        if (iAlfRegisteredEffects[i].iAction == KFadeAction)

            {

            delete iFadeEffectFile;

            iFadeEffectFile = NULL;

            iFadeEffectFile = iAlfRegisteredEffects[i].iEffectFile->AllocL();

            __ALFLOGSTRING1( ">> Setting fade effect file  %S", iFadeEffectFile );

            break;

            }

        }

    }

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

// AddNewScreenL

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

// 

void CAlfBridge::AddNewScreenL(CAlfSharedDisplayCoeControl* aSharedCoeControl)

    {

    TInt screenNumber = iAlfScreens.Count(); // \todo this might not be the same as real WServ screen number

    // We do not yet support drawing winGC draw commands to other than primary screen.

    // As fully functional and tested implementation is not there, better to panic here.

    if (screenNumber!=0)

        {

        __ALFLOGSTRING("CAlfBridge::AddNewScreenL. Fatal error! Only screen 0 is supported in Alf server!");

        User::Invariant();

        }

    CAlfScreen* screen = new(ELeave) CAlfScreen(); 

    CleanupStack::PushL(screen);

    screen->ConstructL(screenNumber, *this, *iHuiEnv, aSharedCoeControl);

    iAlfScreens.AppendL( screen );

    CleanupStack::Pop(screen);

	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFloatingSpriteControlGroup), KHuiRosterShowAtTop, screenNumber); 

	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFullscreenEffectControlGroup), KHuiRosterShowAtTop, screenNumber); 

	screen->iFloatingSpriteControlGroup->SetAcceptInput(EFalse);

	screen->iFullscreenEffectControlGroup->SetAcceptInput(EFalse);

	if ( screen->iFpsControlGroup )

	    {

	    ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFpsControlGroup), KHuiRosterShowAtTop, screenNumber); 

	    screen->iFpsControlGroup->SetAcceptInput(EFalse);

	    }

    }

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

// Dumdidumdidum..

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

void CAlfBridge::AddNewScreenFromWindowL(RWindow* aWindow)

    {

    TInt screenNumber = iAlfScreens.Count(); // \todo this might not be the same as real WServ screen number

    CAlfScreen* screen = new(ELeave) CAlfScreen(); 

    CleanupStack::PushL(screen);

    screen->ConstructL(screenNumber, *this, *iHuiEnv, aWindow);

    iAlfScreens.AppendL( screen );

    CleanupStack::Pop(screen);

	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFloatingSpriteControlGroup), KHuiRosterShowAtTop, screenNumber); 

	ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFullscreenEffectControlGroup), KHuiRosterShowAtTop, screenNumber); 

    screen->iFloatingSpriteControlGroup->SetAcceptInput(EFalse);

    screen->iFullscreenEffectControlGroup->SetAcceptInput(EFalse);

    if ( screen->iFpsControlGroup )

	    {

	    ShowControlGroupL(screen->iDisplay->Roster(), *(screen->iFpsControlGroup), KHuiRosterShowAtTop, screenNumber); 

	    screen->iFpsControlGroup->SetAcceptInput(EFalse);

	    }

    }

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

// AddVisual

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

// 

void CAlfBridge::AddVisual( 

        TInt aWindowNodeId, 

        TInt aClientSideId, 

        TInt aClientSideGroupId,

        CHuiCanvasVisual* aVisual )

    {

    __ALFFXLOGSTRING4("CAlfBridge::AddVisual id: %d (%d,%d), visual: 0x%x", aWindowNodeId, aClientSideId, aClientSideGroupId, aVisual);

    THashVisualStruct visualStruct( aVisual, aClientSideId, aClientSideGroupId);

    iWindowHashArray.Insert( aWindowNodeId, visualStruct );

    iPreviouslySearchedVisualId = aWindowNodeId;

    iPreviouslySearchedVisual = aVisual;

    AMT_INC_COUNTER( iTotalVisualCount );

    AMT_MAP_BRIDGE_ADD_VISUAL();

    }

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

// RemoveVisual

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

// 

void CAlfBridge::RemoveVisual( TInt aWindowNodeId )

    {

    __ALFFXLOGSTRING1("CAlfBridge::RemoveVisual 0x%x", aWindowNodeId);

    iWindowHashArray.Remove( aWindowNodeId );

    iPreviouslySearchedVisualId = 0;

    AMT_DEC_COUNTER( iTotalVisualCount );

    AMT_MAP_INC_VALUE( iIntMap, aWindowNodeId, EAlfModuleTestTypeBridgeReleaseWindow );

    AMT_MAP_SET_VALUE( iBoolMap, aWindowNodeId, ETrue, EAlfModuleTestTypeBridgeReleaseWindow );

    }

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

// FindVisual

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

// 

CHuiCanvasVisual* CAlfBridge::FindVisual(TInt aWindowNodeId )

    {

    if ( iPreviouslySearchedVisualId == aWindowNodeId )

        {

        return iPreviouslySearchedVisual;

        }

    THashVisualStruct* visualStruct = iWindowHashArray.Find( aWindowNodeId );

    if ( visualStruct )

        {

        iPreviouslySearchedVisualId = aWindowNodeId;

        iPreviouslySearchedVisual = visualStruct->iVisual;

        return iPreviouslySearchedVisual; 

        }

    __ALFLOGSTRING1("CAlfBridge::FindVisual - Visual 0x%x not found", aWindowNodeId);

    return NULL;

    }

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

// FindVisualByClientSideId

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

// 

CHuiCanvasVisual* CAlfBridge::FindVisualByClientSideIds(

    TUint32 aClientSideId, 

	TUint32 aClientSideGroupId )

    {

    THashMapIter<TUint32, THashVisualStruct> iter(iWindowHashArray);

    THashVisualStruct const * node = 0;

    do

        {

        node = iter.NextValue();

        if (node 

                && (*node).iClientSideId==aClientSideId

                && (*node).iClientSideGroupId==aClientSideGroupId )

            {

            return (*node).iVisual;

            }

        }

    while(node);

	return NULL;

    }

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

// FindChainedGroup

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

// 

TUint32 CAlfBridge::FindChainedGroup(

    TUint32 aTreeNodeId)

    {

    THashMapIter<TUint32, TChainData> iter(iWindowChainsArray);

    TChainData const * data = 0;

    do

        {

        data = iter.NextValue();

        if (data && data->iParent == aTreeNodeId)

            {

            TUint32 chainedTo = FindChainedGroup(data->iChainee);

            if (!chainedTo)

                {

                return data->iChainee; 

                }

            else

                {

                return chainedTo;

                }

            }

        }

    while(data);

    return NULL;

    }

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

// IsChainedGroup

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

// 

TBool CAlfBridge::IsChainedGroup(

    TUint32 aTreeNodeId)

    {