/*

* Copyright (c) 2005-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:  Implementation for peninput server

*

*/

//  INCLUDE FILES

#include <e32svr.h>

#include <w32std.h>

#include <coedef.h>

#include <apgwgnam.h>

#include <coemain.h>

#include <AknFepInternalCRKeys.h>

#include <akniconconfig.h>

#include <AknSgcc.h> 

#include <sensorplugindomaincrkeys.h> // KCRUidSensorSettings

#ifdef RD_TACTILE_FEEDBACK 

#include <featmgr.h>

#endif //RD_TACTILE_FEEDBACK  

#include "peninputclientserver.h"

#include "peninputserver.h"

#include "peninputserversession.h"

#include <PtiEngine.h>

#include <s32mem.h>

#include <gulgcmap.h>

#include "peninputanimclientobj.h"

#include "peninputuilayoutowner.h"

//#include "aknfeppeninputenums.h"

#include <UikonInternalPSKeys.h>

#include "penuiwndctrl.h"

#include "keyrotator.h"

#include <AknDef.h>

#include <aknfeppeninputenums.h>

#include <aknappui.h> 

#include "peninputcrpclient.h"

#include <avkondomainpskeys.h>

//#define __WND_TEST_

// CONSTANTS

const TSize KInitialPeninputSize= TSize( 10, 10 );

const TInt KMsgQueueLen = 1000;

const TInt KMsgResponseQueueLen = 10;

const TInt KWsSessionFlushPerioid = 50000;//50ms

const TInt KInvalidValue = -1;

// Layout UID for portrait FSQ.  Used for distinguish between 

// landscape and portrait FSQ for EPluginInputModeFSQ, which 

// is used for both orientation in Pen Input server side code.

const TInt KPenInputSrvPrtFsqUiId = 0x20026837;

enum TActivationFlag

	{

	ECmdDeactivate = EFalse,

	ECmdActivate = ETrue,

	};

enum TUpdateFlag

	{

	EPartialUpdate = EFalse,

	EFullUpdate = ETrue

	};

#ifdef __LOG_WNDGROU__	

#ifdef __WINS__

_LIT(KLogFile,"c:\\penwndgroup.txt");

#else

_LIT(KLogFile,"\\penwndgroup.txt");

#endif

#endif //__LOG_WNDGROU__

TUid GetAppUidByWndGroupIdL( RWsSession &aWs, TInt aWndGroupId )

    {

    CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(aWs,aWndGroupId);

    TUid id = wg->AppUid();

    CleanupStack::PopAndDestroy(wg);    	

    return id;

    }

TUid GetFocusAppUid()

    {

    RWsSession &ws = CCoeEnv::Static()->WsSession();

    TInt wgId =ws.GetFocusWindowGroup();

    TUid id = TUid::Null();

    TRAP_IGNORE( id = GetAppUidByWndGroupIdL( ws, wgId ) );

    return id;

    }

#ifdef  __LOG_WNDGROU__

void Des2Des8(const TDesC& aSrc, TDes8& aDest)

    {

    aDest.Zero();

    const TUint16* ptr = aSrc.Ptr();

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

        {

        aDest.Append(*((TUint8*)ptr));

        ptr++;

        }

    }

#endif 

#ifdef __LOG_WNDGROU__    

void WriteDeactivateLogL( RFile& aFile )

    {

    TInt ret = aFile.Open(CCoeEnv::Static()->FsSession(),KLogFile,EFileShareAny|EFileWrite);

    if(ret == KErrNone)

        {

        _LIT8 (KNotesID, "Notes id: %d  \r\n");

        TBuf8<30> buf;

        buf.Zero();

        TInt off = 0;

        aFile.Seek(ESeekEnd,off);

        RWsSession &ws = CCoeEnv::Static()->WsSession();

        TInt wgId =ws.GetFocusWindowGroup();

        CApaWindowGroupName* wgname = CApaWindowGroupName::NewLC(ws,wgId);

        TInt focusuid = GetFocusAppUid().iUid;

        buf.Format(KNotesID, focusuid);

        HBufC8* name = HBufC8::NewLC(wgname->Caption().Length());

        TPtr8 nameStr = name->Des();

        Des2Des8(wgname->Caption(),nameStr);

        aFile.Write(_L8(" ..."));

        aFile.Write(nameStr);            

        aFile.Write(buf);            

        aFile.Write(_L8(" Close UI. \r\n"));

        aFile.Close();

        CleanupStack::PopAndDestroy(name);

        CleanupStack::PopAndDestroy(wgname);

        }

    }

#endif

TBool IsGlobalNotesApp(TUid& aUid)

    {

    const TInt KAknCapServerUid = 0x10207218;

    const TInt KAknNotifySrvUid = 0x10281EF2;      

    if(aUid.iUid == KAknCapServerUid || aUid.iUid == KAknNotifySrvUid)

        return ETrue;

    return EFalse;

    }

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

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

// CPeninputServer::CPeninputServer

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

//

CPeninputServer::CPeninputServer ( TInt aPriority) :  CServer2 ( aPriority,ESharableSessions ),

                            iActive(EFalse),iDispMode(ENone),

                            iDispModeForMask(ENone),

                            iFullUpdate(EFalse),

                            iPrevActive(EFalse),iUILayoutReady(EFalse),

                            iSupportFeedback(EFalse)

    {

    AknIconConfig::TPreferredDisplayMode displayMode;

    AknIconConfig::PreferredDisplayMode(displayMode, AknIconConfig::EImageTypeIcon);

    iDispMode = displayMode.iBitmapMode;

    iDispModeForMask = displayMode.iMaskMode;

    iSpriteMember.iBitmap = NULL;

    iSpriteMember.iMaskBitmap = NULL;   

    iLayoutId.iUid = 0;

    iPrevLayoutId = iLayoutId;

    iSpriteSize = KInitialPeninputSize;

    iSpritePosition = TPoint(0,0);    

    //iDispMode = iDispModeForMask= CCoeEnv::Static()->WsSession().GetDefModeMaxNumColors(col,grey);    

    iPreNonGloebalNotesWndGrpId = -1;

    iNoNeedClean = EFalse;

	iEnablePriorityChangeOnOriChange = ETrue;

    }

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

// CPeninputServer::NewL

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

//

CPeninputServer* CPeninputServer::NewL()

    {

    CPeninputServer* pS = new (ELeave) CPeninputServer(

                                                  CActive::EPriorityStandard);

    CleanupStack::PushL( pS );

    pS->ConstructL( );

    CleanupStack::Pop(pS);

    return pS;

    }

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

// CPeninputServer::ConstructL

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

//

void CPeninputServer::ConstructL( )

    {

#ifdef RD_TACTILE_FEEDBACK     

	FeatureManager::InitializeLibL();

   	iSupportFeedback = FeatureManager::FeatureSupported( KFeatureIdTactileFeedback );

#endif //RD_TACTILE_FEEDBACK   

    // start server, leaves if server already running

    StartL( KPeninputServerName );            

    User::LeaveIfError( iKeyEventSemaphore.CreateGlobal(

                                    KAnimKeyEventSemaphore,0) );

    iEventBufferQueue = CEventQueue::NewL(this,KMsgEventBufferQueue);

    iKeyMsgResponseQueue.CreateGlobal(KMsgEventResponseQueue,KMsgResponseQueueLen);

    iFlushTimer = CPeriodic::NewL(CActive::EPriorityHigh);        

    iHardwareLayoutChangeWatcher = CAknLayoutChangeWatcher::NewL(this,

                                                            KUikLayoutState);

    iSoftwareLayoutChangeWatcher = CAknLayoutChangeWatcher::NewL(this,

                                                   KUikPreferredOrientation);

    iHardwareLayoutChangeWatcher->StartWatching();

    iSoftwareLayoutChangeWatcher->StartWatching();

	RWindowGroup& rootWin = CCoeEnv::Static()->RootWin();

	rootWin.EnableFocusChangeEvents (); // For cover UI/status pane refresh problems

	rootWin.EnableGroupListChangeEvents();

	rootWin.EnableReceiptOfFocus(EFalse);

	rootWin.AutoForeground(EFalse);

    ConstructSpriteL();

    //create animation object

	iAnimObj = CPeninputAnimObj::NewL(iSpriteMember);

	iLayoutOwner = CPeninputUiLayoutOwner::NewL( *this );

	iPenUiCtrl = new(ELeave) CPenUiWndCtrl(CCoeEnv::Static()->RootWin(),iSpriteMember.iBitmap);

	iInternalBackgroundCtrl = new(ELeave) CInternalBkCtrl(CCoeEnv::Static()->RootWin());

    iInternalBackgroundCtrl->ConstructL();	

	iPenUiCtrl->ConstructL();

	iCurScreenFocusedWndGrpId = GetFocusAppUid().iUid;

#ifdef __LOG_WNDGROU__    

    iLogFile.Replace(CCoeEnv::Static()->FsSession(),KLogFile,EFileShareAny|EFileWrite);

    iLogFile.Close();

#endif

    iCurScrMode = CCoeEnv::Static()->ScreenDevice()->CurrentScreenMode();

    iCrpService = CPenInputCrpServiceClient::NewL();

    iSensorRepository = CRepository::NewL(KCRUidSensorSettings);

    User::LeaveIfError(iDiscreetPopProperty.Attach(KPSUidAvkonDomain, 

                                         KAknGlobalDiscreetPopupNumChanged));

    iDiscreetPopSubscriber = new (ELeave) CSubscriber(

            TCallBack( DiscreetPopChangeNotification, this), 

            iDiscreetPopProperty);

    iDiscreetPopSubscriber->SubscribeL();

    // Get the pop area

    User::LeaveIfError(iAknUiSrv.Connect());

    iDiscreetPopArea = iAknUiSrv.GetInUseGlobalDiscreetPopupRect();

    if(iDiscreetPopArea.Size().iWidth > 0)

        {

        HandleDiscreetPopNotification();

        }

    }

void CPeninputServer::CleanAll()

    {

    if(iNoNeedClean)

       return;    

    delete iHardwareLayoutChangeWatcher;

    delete iSoftwareLayoutChangeWatcher;

    if(iAppGc)

        CCoeEnv::Static()->SwapSystemGc(iAppGc);

    delete iPtiEngine;

    iKeyEventSemaphore.Close();

    iUiHandlerArray.Close();

    // iSprite will be closed by iWsSession.Close()

    // but the sprite member bitmaps must be deleted

    // explicitly

    /*

    // iPrevUiLayout is not used any more

    if(iPrevUiLayout && iPrevUiLayout!=iUiLayout)

        {

        iPrevUiLayout->Destroy();        

        iPrevUiLayout = iUiLayout;

        }

        */

    if(iUiLayout)

        {

        iUILayoutReady = EFalse;

        iDestroyingLayout = ETrue;

        iUiLayout->Destroy();

        iUiLayout = NULL;       

        }

    delete iBitmapDevice;

    delete iMaskBitmapDevice;

    delete iSpriteGc;

    delete iSpriteMember.iBitmap;

    delete iSpriteMember.iMaskBitmap;

    delete iWindowGc;            

    delete iLayoutEng;    

    delete iLayoutOwner;

    delete iEventBufferQueue;

    iKeyMsgResponseQueue.Close();

    if(iFlushTimer)

        {

        iFlushTimer->Cancel();

        delete iFlushTimer;

        }

#ifdef RD_TACTILE_FEEDBACK

	FeatureManager::UnInitializeLib();

    iFeedbackAreaArray.Close();

#endif // RD_TACTILE_FEEDBACK    

    delete iPenUiCtrl;

    delete iInternalBackgroundCtrl;

    iClientProcess.Close();

    iClientLayouts.Close();

#ifdef __LOG_WNDGROU__    

    iLogFile.Close();    

#endif

    if (iDiscreetPopSubscriber)

	    {

	    iDiscreetPopSubscriber->StopSubscribe();

	    }

    iDiscreetPopProperty.Close();

    delete iDiscreetPopSubscriber;

    iAknUiSrv.Close();

    delete iAnimObj;

    iAnimObj = NULL;

    iNoNeedClean = ETrue;

    delete iCrpService;

    iCrpService = NULL;

    }

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

// CPeninputServer::~CPeninputServer

// Destructor

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

//

CPeninputServer::~CPeninputServer()

    {

    CleanAll();

#ifdef __WINS__

    iCloseServer = ETrue;

#endif        

    delete iSensorRepository;

    }

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

// CPeninputServer::IncreaseSessionCount

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

//

void CPeninputServer::IncreaseSessionCount()

    {

    ++iSessionCount;

    }

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

// CPeninputServer::DecreaseSessionCount

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

//

void CPeninputServer::DecreaseSessionCount(CPeninputServerSession* aSession)

    {

    if( aSession == iForegroundSession)

        {

        iForegroundSession = NULL;

        Hide();

        }

    else

        {

        if( aSession == iForegroundUiHandler )

            {

            iForegroundUiHandler = NULL;

            }

        }

    //remove the session from list

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

        {

        if( aSession == iUiHandlerArray[i] )

            iUiHandlerArray.Remove(i);

        }

    --iSessionCount;

#ifdef __WINS__

        if ( iSessionCount == 0 && !iCloseServer)

            {

            DeactivateSprite();

            PrepareExit();

            CActiveScheduler::Stop();

            }

#endif

    }

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

// CPeninputServer::ActivateSpriteInGlobalNotesL()

// Activate sprite

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

//

void CPeninputServer::ActivateSpriteInGlobalNotesL()

    {

    TBool notDraw = EFalse;

    if(iUiLayout)

        {

        iUiLayout->HandleCommand( ECmdPeninputDisableLayoutDrawing, 

                                 (unsigned char*)&notDraw );  

        }

    // [[[ temporary solution for Virtual keyboard becomes corrupted after several rotations

    if(!iUiLayout)

    	{

        return;

    	}

    // we should not be able to activate and show pen ui if this mode is disabled currently

    TInt inputType = iUiLayout->PenInputType();

    if( inputType == EPluginInputModeFSQ && iLayoutId.iUid == KPenInputSrvPrtFsqUiId )

        {

        inputType = EPluginInputModePortraitFSQ;

        }

    if( inputType & DisabledByOrientation() )

        {

        // we have activate the animation otherwise we will see the penui but not reponse

        // when clicking on it in the case we rotating the screen quickly and continously

        if(iAnimObj)

            {

            iAnimObj->AddActivationCmd(ECmdActivate,EFalse);                

            }

        return;

        }

    // ]]] temporary solution for Virtual keyboard becomes corrupted after several rotations

    if(iActive)

        {

        if(iUseWindowCtrl)

            {

/*            RWsSession &ws = CCoeEnv::Static()->WsSession();

            TInt wgId =ws.GetFocusWindowGroup();

            //TInt wgHandle = ws.GetWindowGroupHandle(wgId);

            TInt priority;

            //TInt pos;

            //wg.Construct(wgHandle);

            //pos = wg.FullOrdinalPosition();

            priority = ws.GetWindowGroupOrdinalPriority(wgId);*/

            //wg.Close();           

            //iPenUiCtrl->ShowPenUi();

            ActivatePenUiLayout(EFalse);

            iDimmed = EFalse;

            iPenUiCtrl->ShowPenUiL(iDimmed);            

            }

        return;

        }

    TBool bNeedWait = AnimOpNeedWaiting(ESignalPenUiActivated);

    //add animation command

    /*

    if(iAnimObj->AddActivationCmd(ECmdActivate,bNeedWait))

            {

            if(bNeedWait)

                iForegroundUiHandler->AddDelayedCmd();

            //iUiLayout->OnActivate();                  

            ActivatePenUiLayout();

            DrawSprite();        

            iEventBufferQueue->GetEvent();

            iActive = ETrue;                

            if(iUseWindowCtrl)

                iPenUiCtrl->ShowPenUi();

        }

        */