/*

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

                        TBool aIsFullScreenEffect) 

                : iHandle(aHandle), 

                iEffectedVisual(aEffectedVisual),

                iTemporaryPresenterVisual(aTemporaryPresenterVisual),

                iIsLayout(aIsLayout),

                iHideWhenFinished(aHideWhenFinished),

                iCanDestroyOrHideImmediately(aCanDestroyOrHideImmediately),

                iIsFullScreenEffect(aIsFullScreenEffect)

                        {

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

                        };

                TInt iHandle;

                TBool iIsLayout;

                TBool iHideWhenFinished;

                TBool iCanDestroyOrHideImmediately;

                TBool iIsFullScreenEffect;

				// 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, TBool aOnlyForEmbeddedAlfApp = EFalse );

    /**

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

    /**

     * 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 );

    void CleanAllFxVisuals();

    /**

     * 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 );

    void InitializeSwRenderingTarget(CFbsBitmap* aBitmap);

    /**

     * 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();

    /**

     * Modify all effects due to low memory.

     */

    void OnLowMemoryModifyAllEffects();

    /**

     * 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);

    /**

      * removes Alf application window group tag

      */

    void RemoveWindowGroupAsAlfApp(TInt aId);

    // From MHuiSynchronizationObserver

    void Synchronized(TInt aId);

    /*

     * GfxTriggerEndFullScreen

     * 

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

     * the EndFullScreen effect after BeginFullScreen event arrived.

     * 

     */

    void GfxTriggerEndFullScreen(CFullScreenEffectState* aFullScreenEffectData);

    /**

	 * UpdateSecondaryEffectL

	 *

	 * Resolve filename for two part effect that is used with slowly starting applications

	 * 

	 */

    TBool UpdateSecondaryEffectL(const CFullScreenEffectState& aState);

   /*

	*	GfxTriggerEffectWhenFullScreenDrawn

	*

	*	Goes through the given CHuiControl (group which is supposed to show the effect). 

	*   Triggers the effect, if  drawing buffers in group cover the whole screen in the 

	*   current orientation.

	*

	*	@param	aToGroup	Group to be analyzed

	*/

    TBool GfxTriggerEffectWhenFullScreenDrawn(CHuiControlGroup* aToGroup = NULL);

	// Experimental

	TBool IsLayoutSwitchReady( TInt aDuration );

    TBool IsLayoutSwitchReadyRecursive(

            CHuiLayout* aLayout,

            CHuiControlGroup& aControlGroup,

            CHuiControl& aControl,

            TBool& aFullscreenCovered, 

            const TRect& aFullscreen,

            CAlfScreen* aScreen,

            TBool aChildCanBeOpaque, 

            TBool aOnlyForEmbeddedAlfApp,

            TInt aOrientation,

            TInt aDuration,

            TBool& aCoverageRegionModified );

    void LayoutSwitchStart();

    void LayoutSwitchComplete();

    RAlfBridgerClient* BridgerClient();

    /**

     * Refresh requested. This is meant to be used by alfstreamerbridge when

     * frame has ended.

     */

    void RefreshNow(TBool aSyncWait);

    /**

     * Asynchronous refresh when in SW rendering mode.

     */

    void AsynchRefresh();

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 );

	/**

 	 *  HandleSetDistractionWindowL

	 *  

	 *  Define or undefine, window that should be discarded in fullscreen

	 *  heuristic analysus.

	 *

	 *  Used by avkon to mark CAknLocalScreenClearer window.

	 */

    void HandleSetDistractionWindowL( TAlfBridgerData data );

	/**

	*	RemoveEffectFromApp

	*

	*	Removes effects on appui.

	*/

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

    // component effect handling

    void HandleGfxControlEffectsL( TAlfBridgerData data );

   /**

	*	StoreLayoutIfRequiredByEffectL

	*

	*   @param aNeededStoredLayout	Returns ETrue, if storing is required. Otherwise EFalse.

    *

	*	@return ETrue	If storing was required and could be done.

    *					OR storing was not required. 

	*/    

    TBool StoreLayoutIfRequiredByEffectL(CHuiLayout* aLayout, CFullScreenEffectState& aEvent, TBool& aNeededStoredLayout);

    /**

     * 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 aIsFullScreenEffect, TBool aIsExitEffect, TBool aCanDestroyOrHideImmediately);

    /*

     *	AddFxItemL

	 *

	 *	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* AddFxItemL(

            TInt aEffectHandle,

            CHuiVisual* aSourceVisual, 

            CHuiLayout* aTargetLayout, 

            CHuiControl* aEffectControl,

            TBool aInsertTemporaryVisual,

            TBool& aItemDestroyed,

            TBool aIsFullScreenEffect,

            TBool aIsExitEffect = EFalse,

            TBool aCanDestroyOrHideImmediately = EFalse

            );

    /*

     *	AddToEffectLayoutContainerL

     */