/*

* Copyright (c) 2006 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:   window server plugin, used by transition server to control

*                framebuffers.

*

*/

#include <bitstd.h>

#include <s32mem.h> //RMemReadStream

#include <e32cmn.h>

#include <apgwgnam.h>

#include <bautils.h> 

#include <akntranseffect.h> 

#include <akntransitionutils.h>

#include "alfwindowmanager.h"

#include "alfserverdrawer.h"

#include "wsserverdrawercontroller.h"

#include "alfgfxeffects.h"

#include "alfwindow.h"

#include "alfstreamerbridge.h"

#include "alfpolicyhandler.h"

#include <alflogger.h>

#include <uiacceltk/HuiUtil.h>

#ifdef __WINS__

const TInt KAlfShortEffectTimeout = 4000000;

const TInt KAlfLongEffectTimeout  = 5000000;

#else

const TInt KAlfShortEffectTimeout = 2000000;

const TInt KAlfLongEffectTimeout  = 3000000;

#endif

//const TInt KAlfLongEffectTimeout  = 500000;

// Timer to send finish full screen effect

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

// CAlfFinishTimer

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

//

NONSHARABLE_CLASS( CAlfFinishTimer ):public CTimer

    {

    public:  // Constructors and destructor

        static CAlfFinishTimer* NewL();

        virtual ~CAlfFinishTimer();

    public: // New functions

        void Start( TTimeIntervalMicroSeconds32 aPeriod, TCallBack aTimeoutCallback );

    protected:  // Functions from base classes

        void DoCancel();

    private:

        CAlfFinishTimer();

        void ConstructL();

        void RunL();

    private:    // Data

    TCallBack iCallback;

    };

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

// CAlfFinishTimer

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

//

CAlfFinishTimer::CAlfFinishTimer()

    :CTimer ( EPriorityStandard )

    {   

    }

void CAlfFinishTimer::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

CAlfFinishTimer* CAlfFinishTimer::NewL()

    {

    CAlfFinishTimer* self = new ( ELeave ) CAlfFinishTimer;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfFinishTimer::~CAlfFinishTimer()

    {

    Cancel();        

    }

void CAlfFinishTimer::Start( TTimeIntervalMicroSeconds32 aPeriod, TCallBack aTimeoutCallback )

    {

    iCallback = aTimeoutCallback; 

    After( aPeriod );

    }

void CAlfFinishTimer::RunL()

    {

    //

    // timer completes and control is returned to caller

    //

    if ( iStatus.Int() != KErrCancel )

        {

        iCallback.CallBack();

        }

    }

void CAlfFinishTimer::DoCancel()

    {

    CTimer::DoCancel();

    }

NONSHARABLE_CLASS( CPSObserver ): public CActive

    {

    public:

        static CPSObserver* NewL( const TUid& aUid, TInt aKey );

        void StartObserving( TCallBack aCallback, TInt aHandle );

        ~CPSObserver();

    private:

        CPSObserver();

        void ConstructL( const TUid& aUid, TInt aKey );

        void DoCancel();

        void RunL();

    private:

        RProperty iProperty;

        TInt iKey;

        TCallBack iCallback;

        TInt iHandle;

    };

CPSObserver::CPSObserver():

    CActive( CActive::EPriorityHigh )

    {

    }

CPSObserver::~CPSObserver()

    {

    Cancel();

    iProperty.Close();

    }

CPSObserver* CPSObserver::NewL( const TUid& aUid, TInt aKey )

    {

    CPSObserver* self = new ( ELeave ) CPSObserver();

    CleanupStack::PushL( self );

    self->ConstructL( aUid, aKey );

    CleanupStack::Pop( self );

    return self;

    }

void CPSObserver::ConstructL( const TUid& aUid, TInt aKey ) 

    {

    iKey = aKey;

    User::LeaveIfError( iProperty.Attach( aUid, aKey ) );

    CActiveScheduler::Add( this );

    }

void CPSObserver::StartObserving( TCallBack aCallback, TInt aHandle )

    {

    Cancel();

    iHandle = aHandle;

    iCallback = aCallback;

    iProperty.Subscribe( iStatus );

    SetActive();

    }

void CPSObserver::RunL()

    {

    // prepare for stray signals

    iProperty.Subscribe( iStatus );

    SetActive();

    TInt value = -1;

    TInt err = iProperty.Get( value );

    if ( iStatus.Int() != KErrCancel && value == iHandle )

        {

        iCallback.CallBack();

        // Cancel wait for property change until a new effect is started

        Cancel();            

        }

    // If the handle does not match, the ending effect was some earlier one

    // We keep waiting for signal about ending of the correct effect.    

    }

void CPSObserver::DoCancel()

    {

    iProperty.Cancel();

    }

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

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

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

//

CAlfServerDrawer* CAlfServerDrawer::NewL( CAlfWindowManager* aWindowManager,

    CPolicyHandler& aPolicyHandler )

    {

    CAlfServerDrawer* self = new(ELeave) CAlfServerDrawer( aWindowManager, aPolicyHandler );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

    }

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

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

//

void CAlfServerDrawer::ConstructL()

    {

    iController = CWsServerDrawerController::NewL(this);

    iIdle = CIdle::NewL(CActive::EPriorityIdle);

    iFullScreenTimeout = CAlfFinishTimer::NewL();

    iFinishFullScreen = CAlfFinishTimer::NewL();

    iTransitionEndObserver = CPSObserver::NewL( KPSAlfDomain, KAlfTransitionStatus );

    iProperty.Attach( KPSAlfDomain, KAlfTransitionStatus );

    iProperty.Set( KPSAlfDomain, KAlfTransitionStatus, 0 );

    iFs.Connect();

    }

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

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

//

CAlfServerDrawer::CAlfServerDrawer( CAlfWindowManager* aWindowManager,

    CPolicyHandler& aPolicyHandler  ):

    iWindowManager( aWindowManager ),

    iPolicyHandler( aPolicyHandler )

    {

    iScrModeChangedState = EScreenModeChangedIdle;

    }

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

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

//	

CAlfServerDrawer::~CAlfServerDrawer()

    {

    delete iTransitionEndObserver;

    iProperty.Close();

    iFs.Close();

    delete iController;

    delete iIdle;

    delete iFinishFullScreen;

    delete iFullScreenTimeout;

    }

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

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

//

TInt CAlfServerDrawer::BeginControlTransition( TUint aAction, TUid aControlUid,

    TInt aWindowGroup, TInt aWindowHandle)

    {

  	iControlRect = TRect(); // clear the rectangle

    if ( iInScreenModeChange )

        {

        return KErrAbort;

        }

    else

        {

        iControlAction = aAction;

        iControlUid = aControlUid;

        iControlWindowGroup = aWindowGroup;

        iControlHandle = aWindowHandle;

        return iController->BeginControlTransition();

        }

    }

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

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

//	

void CAlfServerDrawer::EndControlTransition(TInt aHandle)

    {

    iController->EndControlTransition(aHandle);

    }

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

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

//		

void CAlfServerDrawer::PrepareFullscreen()

    {

    __ALFFXLOGSTRING(" -> PrepareFullscreen");

    __ALFFXLOGSTRING(" -> PrepareFullscreen end");

    }

void CAlfServerDrawer::UnregisterAllAlfFullScreenEffect()

    {

    TAlfBridgerData bridgerData;  

    bridgerData.Set( EAlfUnregisterAllFx, 0, 0, NULL );              

    iWindowManager->PostIt(bridgerData);

    }

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

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

//  

void CAlfServerDrawer::UnregisterAlfFullScreenEffect( TInt aAction )

    {

    TAlfBridgerData bridgerData;  

    bridgerData.Set( EAlfUnregisterEffectFx, aAction, 0, NULL );              

    iWindowManager->PostIt(bridgerData);

    }

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

// BeginSyncronizedGroup

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

//  

void CAlfServerDrawer::BeginSyncronizedGroup(TInt aGroupId)

    {

    TAlfBridgerData bridgerData;  

    bridgerData.Set( EAlfEffectFxBeginSyncronizedGroup, aGroupId, 0, NULL );              

    iWindowManager->PostIt(bridgerData);

    }

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

// EndSyncronizedGroup

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

//  

void CAlfServerDrawer::EndSyncronizedGroup(TInt aGroupId, TBool aForced)

    {

    TAlfBridgerData bridgerData;  

    bridgerData.Set( EAlfEffectFxEndSyncronizedGroup, aGroupId, aForced, NULL );              

    iWindowManager->PostIt(bridgerData);

    }

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

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

//  

void CAlfServerDrawer::RegisterAlfFullScreenEffect( TInt aAction, const TDesC& aResourceDir,

        const TDesC& aFileName)

    {

    TAlfBridgerData bridgerData;              

    TInt bufferSize = sizeof(TPtrC) + ( aResourceDir.Length()*2) + sizeof(TPtrC) + aFileName.Length() * 2;

    TInt index = 0;

    void* bridgeBuffer = NULL;

    // This function cannot actually leave

    TRAP_IGNORE( bridgeBuffer = (void*)iWindowManager->Bridge()->AppendEffectsDataL( bufferSize, index ) ); 

    if ( bridgeBuffer )

       {

       RMemWriteStream stream( bridgeBuffer, bufferSize );

       // The writes should not leave if we have calculated our buffer length correctly.

       TRAP_IGNORE(

           {

           stream << aResourceDir;

           stream << aFileName;                 

           stream.CommitL();    

           });      

       bridgerData.Set( EAlfRegisterEffectFx, aAction, bufferSize, (TAny*) index );              

       iWindowManager->PostIt(bridgerData);

       stream.Close();

       }

    }

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

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

//	

void CAlfServerDrawer::BeginFullscreen(	TInt aAction, const TRect& aEffectRect,

                                        TInt aType, const TUid aUid1, const TUid aUid2, TInt aData )

    {  

    if ( iController->AppInfoCache().Action(aUid1) == aAction && 

         iController->AppInfoCache().Action(aUid1) !=  AknTransEffect::EApplicationExit )

        {

        __ALFFXLOGSTRING2(" -> CAlfServerDrawer::BeginFullscreen - skipping action: %d, because previous action is stronger: %d", aAction, iAction);

        // the action must be skipped, because stronger action has been request already.

        return;

        }

    __ALFFXLOGSTRING2(" -> CAlfServerDrawer::BeginFullscreen - Action: %d, aType: %d", aAction, aType);

    TInt action = iController->AppInfoCache().SetAction(aUid1, aAction);

    // Skip all embedded and background application effects, for now.

    // This addition is to prevent messaging app popping up in startup.

    // AVKON uses wrong parameter type and so NoEffects is not applied.

    if ( action == AknTransEffect::EEmbeddedApplicationExit ||

         action == AknTransEffect::EEmbeddedApplicationStart || 

         action == AknTransEffect::EAppStartupBackground )

        {

        __ALFFXLOGSTRING1(" -> CAlfServerDrawer::BeginFullscreen - Embedded/background (%d) application, skip effect", aAction);

        return;

        }

    if ( aAction != AknTransEffect::ENone && aAction != AknTransEffect::EAppStartupBackground )

        {

        // no action or background activity won't stop current effect

        // Matrix Menu sends start rect and avkon sends start for the same application!

        // We assume that we want to keep the rect from Matrix Menu if the app id matches 

//        if ( !iDoNotClearEffectRect )

        if ( iToUid == aUid1 &&

            ( iAction == AknTransEffect::EApplicationStartRect || iAction == AknTransEffect::EApplicationStartSwitchRect ) &&

            ( aAction == AknTransEffect::EApplicationStart || aAction == AknTransEffect::EApplicationStartSwitch ) ) 

            {

            // if we have first got a start rect and the basic start for the same application,

            // we save the rectangle information and keep asking an effect with a rectangle

            aAction = iAction; 

            }

        else

            {

            // This is a new event, we change the rectangle

            iEffectRect = aEffectRect;

            }

        }

   	iFlags = AknTransEffect::TParameter::EFlagNone;

	iToUid = KNullUid;

	iFromUid = KNullUid;

	iFocusWg = KErrNotFound;

	iType = aType;

	if ( aType == AknTransEffect::EParameterType )

		{

        __ALFFXLOGSTRING("CAlfServerDrawer::BeginFullscreen - AknTransEffect::EParameterType");    

        iToUid = aUid1;

        iFromUid = aUid2;

        iFlags = aData;  

		}

	if ( aType == AknTransEffect::EParameterAvkonInternal )

	    {

        // here comes in the avkon info, which will tell us the window group id required for the effect EndFullScreen event

        __ALFFXLOGSTRING("CAlfServerDrawer::BeginFullscreen - AknTransEffect::EParameterAvkonInternal");    

        iToUid = aUid1;

        iParentUid = aUid2;

        iFocusWg = aData;	    

        // We save the action in case we haven't got an EndFullScreen call yet

        iOldAction = iAction;

	    }

    iAction = aAction;

    // TODO: TEMPORARY HACK

    // REMOVE AFTER APPSHELL HAS BEEN FIXED

    // commented out to test if the system works now

    /*

    if ( ( iAction == AknTransEffect::EApplicationStartRect || iAction == AknTransEffect::EApplicationStartSwitchRect ) &&

        iToUid.iUid == 0x101F4CD2 )

        {

        iDoNotClearEffectRect = ETrue;

        }

    */   

    // As appshell uses strange values for folder open and close, we change them now.

    /*

    if ( iAction == 1001 && iToUid.iUid == KAknApplicationShellViewId )

       {

       iAction = AknTransEffect::EApplicationStart;

       }

    if ( iAction == 1002 && iToUid.iUid == KAknApplicationShellViewId  )

       {

       // This might not be the right one, but we try if this is OK

       iAction = AknTransEffect::EApplicationExit;

       }

    */       

    __ALFFXLOGSTRING2("CAlfServerDrawer::BeginFullscreen - From UID: 0x%X, To UID: 0x%X, Application UID: 0x%X", iFromUid.iUid, iToUid.iUid );    

    __ALFFXLOGSTRING3("CAlfServerDrawer::BeginFullscreen - Parent UID: 0x%X, Focus window group UID: 0x%X, Flags: 0x%X", iParentUid.iUid, iFocusWg, iFlags);    

    if( aAction == AknTransEffect::ELayoutSwitch )

        {

        iScrModeChangedState = EScreenModeBeginHasBeenCalled;

        }

    else 

        {

        iScrModeChangedState = EScreenModeChangedIdle;

        }

    iController->BeginFullscreen( aType, aUid1, aUid2, aData );

    __ALFFXLOGSTRING("CAlfServerDrawer::BeginFullscreen end");

    }

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

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

//

void CAlfServerDrawer::EndFullscreen()

    {

    __ALFFXLOGSTRING(" -> CAlfServerDrawer::EndFullscreen");

    CancelEndChecker();

    iController->EndFullscreen(EFalse);

    iController->AppInfoCache().ClearActions();

    __ALFFXLOGSTRING("CAlfServerDrawer::EndFullscreen end");

    }

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

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

//	

void CAlfServerDrawer::CancelFullscreen()

    {

    __ALFFXLOGSTRING(" -> CAlfServerDrawer::CancelFullscreen");

    __ALFFXLOGSTRING("CAlfServerDrawer::CancelFullscreen end");

    }

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

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

//	

void CAlfServerDrawer::AbortFullscreen()

    {

    __ALFFXLOGSTRING(" -> CAlfServerDrawer::AbortFullscreen");

    iController->AbortTransition(EAbortFullscreen);

    iController->AppInfoCache().ClearActions();

    __ALFFXLOGSTRING("CAlfServerDrawer::AbortFullscreen end");

    }

TInt CAlfServerDrawer::FailedFullscreen(TAny* aArg) 

	{

	CAlfServerDrawer* self = static_cast<CAlfServerDrawer*>(aArg);

	self->iController->EndExpired(); // The same as if End Checker Expires.

	return EFalse;

	}