/*

* 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:   Server declaration, internal for Nokia

*

*/

#ifndef __ALF_BRIDGE_H__

#define __ALF_BRIDGE_H__

#include <e32hashtab.h>

#define AMT_CONTROL() static_cast<CAlfModuleTestDataControl*>(Dll::Tls())

#include "alfmoduletest.h" 

#include "alfscreen.h"

#include "alfstreamerbridge.h"

#include "alfdecoderserverclient.h"

#include <alf/alfconstants.h>

#include "HuiFxEffect.h"

#include "huisynchronizationobserver.h"

#include <alf/AlfTransEffectPlugin.h>

#include <uiacceltk/HuiDisplay.h>

class CAlfEffectEndTimer;

class CAlfCommandDebug;

class CAlfLayoutSwitchEffectCoordinator;

class RMemReadStream;

class CHuiCanvasVisual;

class CFullScreenEffectState;

class CControlEffectState;

const TInt KAlfBridgeRegionGranularity = 10;

NONSHARABLE_CLASS(CAlfBridge): 

	public CBase, 

    public MAlfStreamerListener, 

    public MHuiDisplayRefreshObserver, 

    public MHuiBitmapProvider,

    public MAlfGfxEffectObserver,

    public MHuiSynchronizationObserver

    {

	// Helper class for keeping ongoing effects in order. Kept in iEffectCleanupStack

    private:

        struct TEffectCleanupStruct

            {

            public:

                TEffectCleanupStruct(

                        TInt aHandle,

                        CHuiVisual* aEffectedVisual,

                        CHuiVisual* aTemporaryPresenterVisual,

                        TBool aIsLayout, 

                        TBool aHideWhenFinished,

                        TBool aCanDestroyOrHideImmediately) 

                : iHandle(aHandle), 

                iEffectedVisual(aEffectedVisual),

                iTemporaryPresenterVisual(aTemporaryPresenterVisual),

                iIsLayout(aIsLayout),

                iHideWhenFinished(aHideWhenFinished),

                iCanDestroyOrHideImmediately(aCanDestroyOrHideImmediately)

                        {

//                        RDebug::Printf("TEffectCleanupStruct - 0x%x 0x%x, %d", iEffectedVisual, iTemporaryPresenterVisual, iIsLayout );

                        };

                TInt iHandle;

                TBool iIsLayout;

                TBool iHideWhenFinished;

                TBool iCanDestroyOrHideImmediately;

				// not own, unless iEffectedVisual has EShouldDestroy flag enabled

                CHuiVisual* iEffectedVisual;

				// owned

                CHuiVisual* iTemporaryPresenterVisual;

            };

public:

    static CAlfBridge* NewL( CAlfStreamerBridge** aHost, CHuiEnv* aEnv );

    ~CAlfBridge();

	void AddNewScreenL(CAlfSharedDisplayCoeControl* aSharedCoeControl);

	void AddNewScreenFromWindowL(RWindow* aWindow);

    /**

     * This method returns the index of first alf controlgroup in the roster.

     * 

     */

    TInt FirstAlfControlGroupIndex( TInt aScreenNumber );

    /**

     * This method returns the index of last alf controlgroup in the roster.

     * 

     */

    TInt LastAlfControlGroupIndex( TInt aScreenNumber );        

    /**

     * Sets flag to indicated that visual tree has changed (in every screen).

     * 

     */

    void SetVisualTreeVisibilityChanged(TBool aChanged);

    /**

     * Solution to reduce active visuals until we handle window tree hierarchy correctly

     */

    void HandleVisualVisibility( TInt aScreenNumber );

    /**

     * Solution to reduce active visuals until we handle window tree hierarchy correctly. 

	 *  Note: Recursive method

     */

    TBool HandleLayoutVisualVisibility(

            CHuiLayout* aLayout,

            CHuiControlGroup& aControlGroup,

            CHuiControl& aControl,

            TBool& aFullscreenCovered, 

            TRect& aFullscreen,

            CAlfScreen* aScreen,

            TBool& aSubtreeVisible,

            TBool& aHasVisualsWithLayers,

            TBool aChildCanBeOpaque );

    /**

     * Updates layer visibilities.

     */

    void HandleLayerVisibility(

            CHuiLayout* aLayout,

            CHuiControlGroup& aControlGroup,

            CHuiControl& aControl,

            TBool aVisible );

    /**

     * This method shows the control group in roster, however the aWhere param

     * is modified so that controlgroup appears at the right position depending on

     * controlgroup type

     *

     */

    void ShowControlGroupL(

            CHuiRoster& aRoster, 

            CHuiControlGroup& aGroup, 

            TInt aWhere, 

            TInt aScreenNumber );

    /**

     * This method sets the windowgroup id for the alf window.

     * 

     */

    void SetAlfWindowGroupId(TInt aAlfWindowGroupId);

    CHuiDisplay* Display(TInt aScreenNum);

    /**

     * AlfAppUi delegates the QT command buffer posting functionality to bridge 

     * through this function. It identifies the corrcet CHuiCanvasVisual, 

     * from the RWindow::ClientId(), that it has got from client

     * and posts the command buffer to that visual. 

     *

     * @param params  QTParams containg window information and command buffer

     * 

     */

    void PostQTCommandBufferL( TAlfQtCommandBufferParams params );

    /**

     * Set the client window where the visual or layout will be drawn to.

     * @param aWindowGroupId Window group id.

     * @param aClientWindowHandle Client side window handle.

     * @param aVisual Visual or layout.

     */

    void SetClientWindowForDrawingL(TInt aWindowGroupId, TInt aClientWindowHandle, CHuiVisual* aVisual);

    // This is the final callback that does the actual work

    // AlfGfxEffectEndCallBack starts a timer, and when the timer finishes,

    // it calls this function

    void TransitionFinishedHandlerL( TInt aHandle );

    // from  MAlfGfxEffectObserver

  	/**

 	 * Function to be called when CHuiFxEffect class effect has ended

  	 * @param aHandle handle of the effect, given when the effect is started

  	 */

    void AlfGfxEffectEndCallBack( TInt aHandle );

    TInt FindClientWindowGroupId( TInt aScreenNumber, CHuiControlGroup& aControlGroup );

    void RemoveAllTemporaryPresenterVisuals();

    /**

     * Helper function to abort fullscreen effect

     * @param aClientRequest ETrue if requested by client.

     */

    void HandleGfxStopEvent( TBool aClientRequest );

    void EnableSwRenderingL(TBool aEnable = ETrue);

    TBool PrepareSwRenderingTarget( CAlfScreen* aScreen );

    /**

     * Sets memory level.

     * @param aMemoryLevel memory level.

     */

    void SetMemoryLevel(THuiMemoryLevel aMemoryLevel);

    /**

     * Sets low memory. This is used by this class.

     * @param aEnabled ETrue if enabled, EFalse if disabled.

     */

    void SetLowMemory(TBool aEnabled);

    /**

     * Requests to force SW rendering to be used.

     * @param aEnabled enabled status.

     * @return error code.

     */

    TInt ForceSwRendering(TBool aEnabled);

    /**

     * Chooses appropriate memory level and informs

     * core toolkit.

     */

    void DoUpdateMemoryLevel();

    /**

     */

    /**

     * Gets size & rotation.

     * @param aSize size.

     * @param aRotation rotation.

     * @return error code.

     */

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

    /**

     * Reads pixels to bitmap.

     * @param aBitmap bitmap.

     * @return error code.

     */

    TInt ReadPixels(CFbsBitmap* aBitmap);

    /**

      * Sets HuiControlGroup as Alf application window group

      */

    void SetWindowGroupAsAlfApp(TInt aId);

    // From MHuiSynchronizationObserver

    void Synchronized(TInt aId);

    /*

     * 

     * GfxTransEffect API gives EndFullScreen events too late. Thus there is a two stage process for triggering 

     * the EndFullScreen effect after BeginFullScreen event arrived.

     * 

     */

	// Experimental

    TBool IsFullScreenDrawn( TInt aOrientation);

private:    

    CAlfBridge( CAlfStreamerBridge** aHost );

    void ConstructL(CHuiEnv* aEnv);

	/**

	* RegisterFadeEffectL

	*

	* Register existing fade effect from MMC (RND ONLY) or ROM.

	*/

    void RegisterFadeEffectL();

    /**

	* DoSetCachedFadeEffectL

	*

	* Resolves the fade effect filename. Speeds up fade effect loading.

	*/    

    void DoSetCachedFadeEffectL();

	void HandleDestroyDisplay( TInt aScreenNumber );

	void HandleRegisterEffectL( TAlfBridgerData data );

	/**

	* DoRegisterEffectL

	*

	* Register effect filename to a certain action in HuiFxEngine

	*/

	void DoRegisterEffectL(const TDesC& aFilename, TInt aAction);

	// effect handling

	void HandleGfxEffectsL( TAlfBridgerData data );

    // remove effect

    // This is needed if we have to abort an effect

    void HandleGfxStopEffectsL( TAlfBridgerData data );

    void HandleGfxStopControlEffectsL( TAlfBridgerData data );

	/**

	*	RemoveEffectFromApp

	*

	*	Removes effects on appui.

	*/

    void RemoveEffectFromApp(TInt aSecureId, TInt aWgId = -1 );

    // component effect handling

    void HandleGfxControlEffectsL( TAlfBridgerData data );

    /**

     * Handles begin and end fullscreen events

     */

    TBool HandleGfxEventL(CFullScreenEffectState& aEvent, CHuiLayout* aToLayout, CHuiLayout *aFromLayout);

    /*

     * ResolveAfterEffectAppearingApplicationL

     * 

     * In case of an exit effect the appearing application is not notifed to alf

     * by the GfxTransEffect API. In such case it is being resolved from Roster by

     * taking the application directly under the application that is being moved

     * to the background (when called by HandleReorderWindow) or being destroyed

     * (called by DeleteControlGroupL).

     * 

     * In some situation Alf may end up with wrong appearing application uid. In such

     * case the worst that can happen, is that we must wait the frameworks

     * EndFullScreen event to arrive.

     */

    void ResolveAfterEffectAppearingApplicationL(CHuiControlGroup* aGroup);

	/**

	*	FreezeLayoutUntilEffectDestroyedL

	*

	*	Tries to take screenshot of the layout. If that fails, the layout will not be effected at all.

	*/

    void FreezeLayoutUntilEffectDestroyedL(CHuiLayout* aLayout, TInt aHandle);

    /**

     * Handles control effect events

     */    

    void HandleGfxControlEventL(CControlEffectState& aEvent, CHuiCanvasVisual* aCanvasVisual);

    /*

     * SetupEffectLayoutContainerL

     * 

     * This method creates an own layout into iFullScreenEffectControlGroup. Then it creates

     * temporary presenter visual visuals for each visual in aSourceLayout and binds them

     * using SetExternalContentL. Finally the effect entry is added to iEffectCleanupStack, 

     * thus it can be cleaned after effect completion.

	 *

	 *

	 *	@return	ETrue, 	if layout have been initialized succesfully for the effect

	 			EFalse,	if any visuals have been removed. Effect should not be applied.

     */

    TBool SetupEffectLayoutContainerL(TInt aHandle,CHuiLayout* aSourceLayout, TBool aIsExitEffect, TBool aCanDestroyOrHideImmediately);

    /*

     *	AddEffectItemL

	 *

	 *	Prepares visual for the effect. Removes previous effect if necessary. @aItemDestroyed will return EFalse,

	 *	if the visual has been destroyed during the previous effect.

	 *	

	 *	@param	aItemDestroyed	

     */

    CHuiCanvasVisual* AddEffectItemL(

            TInt aEffectHandle,

            CHuiVisual* aSourceVisual, 

            CHuiLayout* aTargetLayout, 

            CHuiControl* aEffectControl,

            TBool aInsertTemporaryVisual,

            TBool& aItemDestroyed,

            TBool aIsExitEffect = EFalse,

            TBool aCanDestroyOrHideImmediately = EFalse);

    /*

     *	AddToEffectLayoutContainerL

     */

    void AddToEffectLayoutContainerL(

            TInt aEffectHandle,

            CHuiLayout* aSourceLayout, 

            CHuiLayout* aTargetLayout,

            CHuiControl* aEffectControlGroup,

            TInt& aItemsDestroyed,

            TBool aAddLayout = ETrue,

            TBool aIsExitEffect = EFalse,

            TBool aCanDestroyOrHideImmediately = EFalse);

    /*

     *	ListFamilyTreeL

     */   

    void ListFamilyTreeL( RPointerArray<CHuiLayout>& aArray, const CHuiLayout* aLayout );

    /*

     * RemoveTemporaryPresenterItem

     * 

     * Effects are shown indirectly by a another visual, that is in iFullScreenEffect control group. 

     * This methods unbinds the external content and the removes temporary presenter visual 

	 * from iFullScreenEffect group and . It does not delete the CHuiFxEffect 

	 * object associated with the content visual. See also iEffectCleanupStack.  

     */

    TBool RemoveTemporaryPresenterItem(TEffectCleanupStruct& aEffectItem);

    /*

     * FindTemporaryPresenterLayout

     * 

     * Finds temporary presenter layout based on a visual.

     *

     * @param   aVisual 

     * 

     * @return  NULL, if visual does not have temporary presenter visual in the active effect list

     */

    CHuiLayout* FindTemporaryPresenterLayout(CHuiVisual* aVisual);

    /*

     * FindLayoutByEffectHandle

     * 

     * Application exit effect for application that does not stay background is destroyed and removed

     * from normal control groups. FindLayoutByEffectHandle is used to find the correct group 

     * in order to apply the exit effect on already "destroyed" application. 

     *

     * @param   aHandle     Effect handle.

     * 

     * @return  NULL, if visual does not have temporary presenter visual in the active effect list

     */

    CHuiLayout* FindLayoutByEffectHandle(TInt aHandle);

    /**

     * HasActiveEffect

	 *

	 *	Note. The visual might not have effect, but it is child for visual that has effect. 

	 *	In both cases, this method returns ETrue. Otherwise EFalse.

	 *

	 *	@param	aVisual	Visual to be checked for effect participation.

     */

    TBool HasActiveEffect(CHuiVisual* aVisual);

    /**

     * HasActiveEffect

	 *

	 *	Note. The visual might not have effect, but it is child for visual that has effect. 

	 *	In both cases, this method returns ETrue. Otherwise EFalse.

	 *

	 *	@param	aVisual	Visual to be checked for effect participation.

	 *	@param  aIndex	Index of the effect item in iEffectCleanupStack, if found. Otherwise KErrNotFound

     */    

    TBool HasActiveEffect(CHuiVisual* aVisual, TInt& aIndex);

   /*

	*	FindEffectHandle

	*

	*	@return 	Returns the effect handle number, which is associated with this visual. If none found, then 

	*               returns KErrNotFound.

	*/

    TInt FindEffectHandle(CHuiVisual* aVisual);

    /*

     * RemoveTemporaryPresenterVisual

     * 

     * Effects are shown indirectly by a another visual, that is in iFullScreenEffect control group. 

     * This methods unbinds the external content and the removes temporary presenter visual 

	 * from iFullScreenEffect group and . It does not delete the CHuiFxEffect 

	 * object associated with the content visual. See also iEffectCleanupStack.  

     */

    TBool RemoveTemporaryPresenterVisual(CHuiVisual* aVisual, TInt aHandle = KErrNotFound);

    /*

     *	RemoveTemporaryPresenterVisuals

     *