/*

* Copyright (c) 2006-2007 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:   Implements CHuiStatic, static data access and utility 

*                functions such as timing.

*

*/

#include "uiacceltk/HuiStatic.h"  // Class definition

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiEnv.h"

#include "HuiRenderPlugin.h"

#include "huistatictlsdata.h"

#include "uiacceltk/HuiProbe.h"

#include <e32math.h>

#include <eikenv.h>

#include <flogger.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <AknBidiTextUtils.h>

#include <bidivisual.h>

#include "alfappfwproxyops.h"

// Global writeable data, used in HW instead of TLS which relatively slow

#ifndef __WINSCW__

TTlsData globalWriteableData;

#endif

void CleanupWg(TAny* aWg)

    {   

    RWindowGroup* wg = static_cast<RWindowGroup*>(aWg);

    delete wg;

    }

/** Dummy implementation for HuiProbe, to be used when external probe is not set */

NONSHARABLE_CLASS(TFakeProbe) : public MHuiProbe

    {

public:

    virtual void ReportObjectLifeCycleEvent(const MHuiSessionObject&, TLifecycleEvent) {}

    virtual void ReportProgramFlowEvent(TProgramFlowPoint, TProgramFlowEvent) {}

    virtual void ReportProgramFlowEvent(const MHuiSessionObject&, TProgramFlowPoint, TProgramFlowEvent) {}

    void ReportFrameRate(TInt) const {}

    void AssociateWithCurrentSession(MHuiSessionObject&) {}

    };

NONSHARABLE_CLASS(CAppFwProxy): public CBase

    {

public:

    class CAlfGuardedSynchCall: public CActive

        {

        public:

        CAlfGuardedSynchCall(const TAlfCommandParams& aParams):CActive(CActive::EPriorityStandard), iPckg(aParams), iPtr(0,0)

            {

            CActiveScheduler::Add(this);

            iStatus = KErrNotFound;

            }

        static TInt DoGuardedOpErrL(const TAlfCommandParams& aInParams, 

                                  TDes8& aOutParams,

                                  RNotifier& aNotifier,

                                  const TDesC8* aInParams2 = 0 // ugly extension, really

                                  )

            {

            CAlfGuardedSynchCall* me = new (ELeave) CAlfGuardedSynchCall(aInParams);

            CleanupStack::PushL(me);

            User::LeaveIfError(me->iTimer.CreateLocal());

            me->iRetBuf = aOutParams.AllocL();

            me->iPtr.Set((TUint8*)me->iRetBuf->Ptr(),0,aOutParams.MaxSize());

            if (aInParams2)

                {

                me->iAltInBuf = aInParams2->AllocL();

                }

            CleanupStack::Pop(); // me

            if (aInParams2)

                {

                aNotifier.StartNotifierAndGetResponse(me->iStatus, 

                                                      TUid::Uid(KAlfAppFwProxyUid), 

                                                      *me->iAltInBuf, me->iPtr);

                }

            else

                {

                aNotifier.StartNotifierAndGetResponse(me->iStatus, 

                                                      TUid::Uid(KAlfAppFwProxyUid), 

                                                      me->iPckg, me->iPtr);

                }                        

            me->iTimer.After(me->iTimerStatus, 100000); // 100ms

            User::WaitForRequest(me->iStatus, me->iTimerStatus);

            TBool timedOut = (me->iStatus == KRequestPending);

            me->iTimer.Cancel(); // Cancel timer anyway

            if (!timedOut)

                {

                TInt err = me->iStatus.Int();  

                User::WaitForRequest(me->iTimerStatus);

                aOutParams.Copy(*me->iRetBuf);    

                delete me;

                return err;

                }

            else 

                {

                me->SetActive(); 

                return KErrTimedOut;

                }

            }

        static void DoGuardedOpL(const TAlfCommandParams& aInParams, 

                                  TDes8& aOutParams,

                                  RNotifier& aNotifier,

                                  const TDesC8* aInParams2 = 0 // ugly extension, really

                                  )

            {

            TInt err = DoGuardedOpErrL(aInParams, aOutParams, aNotifier, aInParams2);

            User::LeaveIfError(err);

            }

        static TInt DoGuardedOp(const TAlfCommandParams& aInParams, 

                                  TDes8& aOutParams,

                                  RNotifier& aNotifier)

            {

            TInt ret = KErrNone;    

            TInt err = KErrNone;

            TRAP(ret, err = DoGuardedOpErrL(aInParams, aOutParams, aNotifier);)

            if (ret == KErrNone)

                {

                ret = err;

                }

            return ret;

            }    

        ~CAlfGuardedSynchCall()

            {

            Cancel();

            delete iRetBuf;

            delete iAltInBuf;

            iTimer.Close(); 

            }

        void RunL()

            {           

            delete this;

            }

        void DoCancel()

            {

            // Cancel will call User::WaitForRequest for iStatus (if this ao is active)

            }

        TPckgC<TAlfCommandParams> iPckg;

        HBufC8* iRetBuf;

        HBufC8* iAltInBuf;

        TPtr8 iPtr;

        RTimer iTimer;

        TRequestStatus iTimerStatus;

        };

    class CAlfLayoutListener: public CActive

        {

        public:

        CAlfLayoutListener(CAppFwProxy& aNotif):CActive(CActive::EPriorityStandard), iNotif(aNotif)

            {

            CActiveScheduler::Add(this);

            iStatus = KErrNotFound;    

            }

        ~CAlfLayoutListener()

            {

            Cancel();    

            }

        void RunL()

            {           

            iNotif.iLayoutMirrored = (iStatus.Int() > 0);         

            SetActive();

            TAlfCommandParams params={EAlfIsMirrorred,0,0,0};

            iParams() = params;

            iNotif.iNotif.StartNotifierAndGetResponse(iStatus,TUid::Uid(KAlfAppFwProxyUid), iParams, iAwkwardApiDummy);

            }

        void DoCancel()

            {

            // just wait for notifier completion    

            User::WaitForRequest(iStatus);    

            }    

        private:

            CAppFwProxy& iNotif;

            TBuf8<1> iAwkwardApiDummy;

            TPckgBuf<TAlfCommandParams> iParams;

            };    

    CAppFwProxy():iLayoutMirrored(KErrNotFound)

        {}

    ~CAppFwProxy()

        {

        if (iConnected)

            {

            iNotif.Close();

            delete iLayoutUpdateAo;

			}

		}

    TBool Connect()

        {

        if (!iConnected)

            {

            // perhaps should check also whether eikon server / notifier server exists..

            // This is currently unsafe (synch) call to a process that may be blocked by window server, keep fingers crossed

            iConnected = (iNotif.Connect() == KErrNone);

            }

        return iConnected;

        }

    TBool LayoutMirrored()

        {                

        if ( Connect() && iLayoutMirrored == KErrNotFound)

            {

            TRequestStatus status;

            TAlfCommandParams inParams={EAlfIsMirrorred,0,0,0};

            TBuf8<1> outParams;

            TInt ret = CAlfGuardedSynchCall::DoGuardedOp( inParams, outParams , iNotif );

            // order updates

            iLayoutUpdateAo = new CAlfLayoutListener(*this);

            if (iLayoutUpdateAo)

                {

                TRAP_IGNORE(iLayoutUpdateAo->RunL());

                }

            iLayoutMirrored = ret > 0;

            }

        return iLayoutMirrored==KErrNotFound?EFalse:iLayoutMirrored;    

        }

    TInt SoftKeyOrientation()

        {

        TInt ret = 0;

        if ( Connect() )

            {

            TAlfCommandParams inParams={EAlfCbaLocation,0,0,0};

            TBuf8<1> outParams;

            ret = CAlfGuardedSynchCall::DoGuardedOp( inParams, outParams , iNotif );

            }

        return ret;    

        }

    TRect LayoutMetricsRect(TInt aType)

        {

        TRect ret=TRect(0,0,0,0);

        if ( Connect() )

            {

            TAlfCommandParams inParams={EAlfLayoutMetricsRect,aType,0,0};

            TPckg<TRect> outParams(ret);

            CAlfGuardedSynchCall::DoGuardedOp( inParams, outParams , iNotif );

            }

        return ret;    

        }

    TInt GetCachedColor(TRgb& aRgb, const TAknsItemID& aID,

            const TInt aIndex )

        {

        if ( Connect() )

            {

            TAlfCommandParams inParams={EAlfGetCachedColor,aID.iMajor,aID.iMinor,aIndex};

            TPckg<TRgb> outParams(aRgb);

            return CAlfGuardedSynchCall::DoGuardedOp( inParams, outParams , iNotif);

            }

        return KErrCouldNotConnect;    

        }

    void GetSkinBitmapL(CFbsBitmap* aBitmap, CFbsBitmap* aMask, const TAknsItemID& aID, const TDesC& aFileName, TInt aBitmapId, 

                        TInt aMaskId, const TSize& aSize, TScaleMode aScaleMode)

        {

        if ( Connect() )

            {

            TAlfCommandParams fakeParams={0,0,0,0};    

            TAlfCommandParams2 inParams={EAlfGetSkinBitmap,aID.iMajor,aID.iMinor,aBitmapId,aMaskId,aFileName, aSize, aScaleMode};

            TPckgC<TAlfCommandParams2> inBuf(inParams);

            TInt2 handles = {0,0};

            TPckg<TInt2> outParams(handles);

            CAlfGuardedSynchCall::DoGuardedOpL( fakeParams, outParams , iNotif, &inBuf );

            if (!handles.iInt1)

                {

                User::Leave(KErrNotFound); 

                }   

            User::LeaveIfError(aBitmap->Duplicate(handles.iInt1));

            if ( aMask && handles.iInt2 )

                {

                User::LeaveIfError(aMask->Duplicate(handles.iInt2));                    

                }

            }

        }

    void GetSkinBackgroundBitmapL(CFbsBitmap* aBitmap, const TAknsItemID& aID )

        {

        if ( Connect() )

            {

            TAlfCommandParams inParams={EAlfGetSkinBackgroundBitmap,aID.iMajor,aID.iMinor,0};

            TInt handle = 0;

            TPckg<TInt> outParams(handle);

            CAlfGuardedSynchCall::DoGuardedOpL( inParams, outParams , iNotif );

            User::LeaveIfError(aBitmap->Duplicate(handle));

            }

        }

    void GetCachedSkinItemDataArrayL(const TAknsItemID& aID, TInt aType, TAlfCachedSkinItemArray& aArray)  

        {

        if ( Connect() )

            {

            TAlfCommandParams inParams={EGetCachedSkinItemData,aID.iMajor,aID.iMinor,aType};

            TPckg<TAlfCachedSkinItemArray> outParams(aArray);

            CAlfGuardedSynchCall::DoGuardedOpL( inParams, outParams , iNotif );

            }

        }

    public: 

        TBool iLayoutMirrored;

        RNotifier iNotif;

        TBool iConnected;

        CAlfLayoutListener* iLayoutUpdateAo;

    };

CHuiStatic* CHuiStatic::NewLC(CHuiEnv* aPrimaryEnv)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aPrimaryEnv);

    return self;

    }

CHuiStatic* CHuiStatic::NewL(CHuiEnv* aPrimaryEnv)

    {

    CHuiStatic* self = NewLC(aPrimaryEnv);

    CleanupStack::Pop(self);

    return self;

    }

CHuiStatic::CHuiStatic()

    {

    }

void CHuiStatic::ConstructL(CHuiEnv* aPrimaryEnv)

    {

    iData = new (ELeave) TTlsData();

    iData->iPrimaryEnv = aPrimaryEnv;

    iData->iIdCounter = -1;

    iData->iTimeFactor = 1.0;

    iData->iIsFirstUpdateTime = ETrue;

    iData->iFirstUpdateTime.UniversalTime();

    iData->iUniversalTime.UniversalTime();

    iData->iRealUniversalTime.UniversalTime();

    iData->iLastFpsTime.UniversalTime();

    iData->DoInitL(); // make sure that we have infra even CCoeEnv was not there

    // Re-construct the virtual table for iFakeProbe

    iData->iFakeProbe = new (ELeave) TFakeProbe;

    iData->iAppFwProxy = new (ELeave) CAppFwProxy;

    //Register for environment change ( here system time change ) event notification

    iChangeNotifier = CEnvironmentChangeNotifier::NewL(0, TCallBack(CHuiStatic::SettingChangedCallBack, this));

    iChangeNotifier->Start();

#ifndef __WINSCW__

    globalWriteableData = *iData;

    #ifdef USE_MODULE_TEST_HOOKS_FOR_ALF

        // For testing purposes, test data needs to be included into TLS

        // because test cases require information stored in TLS.

        if ( !Dll::Tls() )

            {

            Dll::SetTls( iData );    

            }

    #endif    

#else

    Dll::SetTls(iData);

#endif

#ifndef WIN32

#ifdef HUI_DEBUG_WITH_PRINTF

    EnableLogging();

#endif

#endif

    }

CHuiStatic::~CHuiStatic()

    {

    if(iData)

        {

        if(iData->iFakeProbe)

            {

            delete iData->iFakeProbe;

            iData->iFakeProbe = NULL;

            }

        iData->iLogFile.Close();

        delete iData->iAppFwProxy;

        iData->Disconnect();

        }

    iChangeNotifier->Cancel();

    delete iChangeNotifier;

#if defined( __WINSCW__ ) || defined( USE_MODULE_TEST_HOOKS_FOR_ALF )

    Dll::FreeTls();

#endif

    delete iData;

    }

EXPORT_C TTlsData* CHuiStatic::Data()

    {

#ifndef __WINSCW__

    return &globalWriteableData;

#else

    return static_cast<TTlsData*>(Dll::Tls());

#endif

    }

void CHuiStatic::UpdateTime(TTlsData* aData)

    {

    ASSERT( aData );

    // Updates the toolkit's time counters. This includes the toolkit's

    // realtime clock, the internal absolute clock (which is affected by the

    // time factor), the amount of elapsed time since last UpdateTime()

    // invocation, and the amount of elapsed time since the first UpdateTime()

    // invocation (which was done in the beginning of the first refresh).

    if(aData->iIsFirstUpdateTime)

        {

        aData->iIsFirstUpdateTime = EFalse;

        aData->iFirstUpdateTime.UniversalTime();

        aData->iUniversalTime = aData->iFirstUpdateTime;

        aData->iRealUniversalTime = aData->iUniversalTime;

        return;

        }

    TTime now;

    now.UniversalTime();

    // Advance the toolkit's internal clock, applying the time factor.

    if(!aData->iTimePaused)

        {

        aData->iInternalElapsed = now.MicroSecondsFrom(aData->iRealUniversalTime).Int64();

        aData->iInternalElapsed = (TInt64)((TReal32)aData->iInternalElapsed * aData->iTimeFactor);

        aData->iUniversalTime += TTimeIntervalMicroSeconds(aData->iInternalElapsed);

        }

    else

        {

        aData->iInternalElapsed = aData->iInternalElapsedBeforePausing;

        aData->iInternalElapsedBeforePausing = 0;        

        }

    aData->iRealUniversalTime = now;      

    }

TUint32 CHuiStatic::MilliSecondsSinceUpdateTime()

    {

    TTlsData* data = Data();

    TTime now;

    now.UniversalTime();

    return now.MicroSecondsFrom(data->iRealUniversalTime).Int64() / 1000;

    }

EXPORT_C CHuiEnv& CHuiStatic::Env()

    {

    if(!Data())

        {

        THuiPanic::Panic(THuiPanic::EStaticDataNotCreated);

        }

    return *Data()->iPrimaryEnv;

    }