/*

* Copyright (c) 2005-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:  

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefconst.h>

#include <uikon/eikenvinterface.h>

#endif

#include <eikstart.h>

#include <AknDef.h>

#include <barsread.h>

#include <bautils.h>

#include <e32std.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>     // KUikLayoutState, KPSUidUikon, KUikAppHiddenList

#include <AknFepInternalCRKeys.h>    // KAknFepHashKeySelection, KAknFepEditTextSubmenu

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include <AknFepInternalPSKeys.h>    // KAknFepFnKeyState

#endif

#include "avkoninternalpskeys.h"     // KAknIdleAppWindowGroupId

#include <AknCapServerDefs.h>

#include <activeidle2domainpskeys.h>

#include <eikpriv.rsg>

#include <coedef.h>

#include <eiksvdef.h>

#include <aknconsts.h>

#include <AknsConstants.h>

#include <apgwgnam.h>

#include "AknCapServerDefs.h"

#include "AknCapServerEntry.h"

#include "AknCapServer.h"

#include "AknFastswapWindowControl.h"

#include "AknMemoryCardDialogImpl.h"

#include "oommonitor.h"

#include "AknKeyFilter.h"

#include <AknWsEventObserver.h>

#include <PtiEngine.h>

#include <PtiKeyMappings.h>

#include <PtiDefs.h>

// For Gs to initiate OFN status

#include <settingsinternalcrkeys.h>

#include <aknenv.h>

#include <AknSettingCache.h>

#include <eikspane.h>

#include "aknstatuspanedatapublisher.h"

#include <syslangutil.h> // SysLangUtil::GetInstalledLanguages

#include <featmgr.h>

#include <centralrepository.h>

#include "aknmessagereaderlongpressdetector.h" // MAknMessageReaderLongPressDetector

#include <akncapserveralternatefsplugin.h>

#include <akncapserveralternatefspluginconst.hrh>

#ifdef RD_UI_TRANSITION_EFFECTS_LAYOUT_SWITCH

    #include <gfxtranseffect/gfxtranseffect.h>

    #include <akntranseffect.h> // for Transition effect enumerations

#endif

#ifdef SYMBIAN_BUILD_GCE

    #include <alf/alfclientbase.h>

#endif    

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include <AvkonInternalCRKeys.h>

#include "akncapserverdiscreetpopuphandler.h"

const TUid KPtiEnginePSUid = {0x101F8610}; // Same as PtiEngine dll

enum TPtiEnginePSKeys

    {

    EKeyMapPropertyCount,

    EKeyMapPropertyData,

    EKeyMapPropertyCount2,

    EKeyMapPropertyData2,    

    EKeyMapPropertyCount3,

    EKeyMapPropertyData3        

    };

 // Read capability: AlwaysPass.

_LIT_SECURITY_POLICY_PASS( KCapServerPtiEngineAlwaysPass );    

_LIT_SECURITY_POLICY_S1( KCapServerPtiEngineWritePolicy, 0x10207218, ECapabilityWriteDeviceData);  

#endif

// External keyboard modifier

const TUint KModifierExternalKeyboard = 0x00200000;

const TInt KWgPriorityCoverEverything = 10000;

const TInt KKeyEventICodeThreshold = 0x001f;

const TInt KMaxLanguageCodeLength = 6; // 5 digits + separator

const TInt KRemoveBlankDelay = 200000; // 0.2s     

_LIT(KEikSrvUIResFileName, "z:\\resource\\eiksrvui.rsc");

_LIT_SECURITY_POLICY_PASS(KPassReadPolicy);

_LIT_SECURITY_POLICY_C1(KWriteDDPolicy, ECapabilityWriteDeviceData);

_LIT_SECURITY_POLICY_C1(KReadPolicy,    ECapability_None);

_LIT( KSeparator, " " );

CAknCapServerApplication::CAknCapServerApplication()

    {

    }

void CAknCapServerApplication::NewAppServerL(CApaAppServer*& aAppServer)

    {

    CAknCapServer* server = new (ELeave) CAknCapServer();

    CleanupStack::PushL(server);

    server->CreateDynamicSoftNoteEventManagerL();

    CleanupStack::Pop(server);    

    server->SetPriority(EActivePriorityIpcEventsHigh);

    aAppServer=&*server;

    iCapServer = server;

    }

CApaDocument* CAknCapServerApplication::CreateDocumentL()

    {

    return new (ELeave) CAknCapAppServerDocument(*this);

    }

CEikAppUi* CAknCapAppServerDocument::CreateAppUiL()

    {

    CAknCapServerApplication* app = static_cast<CAknCapServerApplication*>(iApp);

    CAknCapServer* server = app->CapServer();

    CAknCapAppServerAppUi* ret = new (ELeave) CAknCapAppServerAppUi( server );

    return ret;

    }

CAknCapAppServerAppUi::CAknCapAppServerAppUi( CAknCapServer* aCapServer ) : iCapServer( aCapServer )

    {

    iIdleActive = ETrue;

    }

CAknCapAppServerAppUi::~CAknCapAppServerAppUi()

    {

    delete iAlternateFS;

    delete iTelephonyIdleUidSubscriber;

    delete iGlobalNotesAllowedSubscriber;

    if (iKeyCaptureControl)

        {

        RemoveFromStack(iKeyCaptureControl);   // ownership in stack 

        }

    delete iFSControl;

    if (iResourceFileOffset)

        {

        iCoeEnv->DeleteResourceFile(iResourceFileOffset);   

        }

    delete iHiddenList;

    delete iMMCUnlock;

    delete iIdler;

    iEikSrv.Close(); // this shouldn't be connected here anyway

    delete iPtiEngine;                          

    iAlfClient.Close();	

    }

_LIT(KProductSpecificHalFile, "z:\\system\\data\\ProductSpecificHalParams.txt");

void DoProductSpecificHalFunction()

    {

    RFs& fs = CCoeEnv::Static()->FsSession();

    RFile file;

    if (fs.Handle() && file.Open(fs,KProductSpecificHalFile, EFileRead)==KErrNone)

        {

        TBuf8<30> desc;

        file.Read(desc);

        TLex8 lex(desc);

        TInt i[4];

        TInt ii = 0;

        for (;ii < 4; ii++)

            {

            if (lex.Val(i[ii]))

                {

                ii = KErrArgument;

                break;

                }

            lex.SkipSpace();

            }

        if (ii != KErrArgument)

            {

            UserSvr::HalFunction(i[0], i[1], &i[2], &i[3]);         

            }

        file.Close();

        }

    }

TInt StartOOM(TAny* aThis)

    {

    // By running idle priority active object twice, we allow idle priority objects

    // scheduled after AppUi::ConstructL() run at least once.

    CAknCapAppServerAppUi* me = (CAknCapAppServerAppUi*)aThis;

    if (!me->iHasRunOnce)

        {

        DoProductSpecificHalFunction();

        me->iHasRunOnce = ETrue;        

        me->iIdler->Start(TCallBack(StartOOM, aThis));

        return KErrNone;

        }

    // free resources of idler

    delete me->iIdler;

    me->iIdler = 0;

    // do the actual startup

    TRAPD( err, CreateOOMWatcherThreadL());

    // we panic here if something goes wrong as startup will fail anyway.

    __ASSERT_ALWAYS(err==KErrNone, User::Invariant());

    me->iEikSrv.AllowNotifierAppServersToLoad();

    me->iEikSrv.Close(); // currently there is no use to keep this session alive.

#ifdef SYMBIAN_BUILD_GCE

    TRAP(err, CAlfAsynchStartup::StartL());

#endif     

    return err;

    }

void CAknCapAppServerAppUi::LoadAlternateFsPlugin()

    {

    // List all plugins

    RImplInfoPtrArray implInfoArray;

    TRAPD( error, REComSession::ListImplementationsL(

        TUid::Uid( KAknCapServerAlternateFsPluginInterfaceUid ), implInfoArray ) );

    if ( error == KErrNone && implInfoArray.Count() )

        {

        TUid uid = implInfoArray[0]->ImplementationUid();

        TRAP_IGNORE( iAlternateFS = CAknCapAppServerAlternateFs::NewL( uid ) );

        }

    implInfoArray.ResetAndDestroy();

    }

void CAknCapAppServerAppUi::ShowOrDismissAlternateFs()

    {

    if ( !iAlternateFS )

        {

        return;

        }

    if ( iAlternateFS->IsVisible() )

        {

        iAlternateFS->HandleLongAppKeyPress();

        }

    else

        {

        iAlternateFS->Show();

        }

    }

void CAknCapAppServerAppUi::ConstructL()

    {

    User::SetCritical(User::ESystemCritical);

    InitiateOFNStatus();

    iEikonEnv->SetSystem( ETrue );

    // install default FEP if none set before

    if (iEikonEnv->FepUid() == KNullUid)

        {

        iEikonEnv->InstallFepL(TUid::Uid(0x101FD65A));

        }

    // define and set the PS key listing installed languages

    PublishInstalledLanguagesL();

    TInt value = 1;

    if ( FeatureManager::FeatureSupported( KFeatureIdEditKey ) )

        {

        // The edit key exists in the device. Hash-key selection disabled and

        // edit text sub-menu removed from the options menu

        value = 0;

        }

    CRepository* repository = CRepository::NewL(KCRUidAknFep);

    // Return value of repository->Set() ignored.

    repository->Set(KAknFepHashKeySelection, value);

    repository->Set(KAknFepEditTextSubmenu, value);

    delete repository;

    repository = NULL;

    // kick eikon server in (in case it is not running yet)

    TInt error = iEikSrv.Connect();

    __ASSERT_ALWAYS(error == KErrNone, User::Invariant());

    // base call

    CAknNotifierAppServerAppUi::ConstructL();

    RWsSession& wsSession=iEikonEnv->WsSession();

    iBackdropWindowGroup=RWindowGroup(wsSession);

    User::LeaveIfError(iBackdropWindowGroup.Construct((TUint32)&iBackdropWindowGroup, EFalse));

    iBackdropWindowGroup.AutoForeground(EFalse);

    CApaWindowGroupName* apaName = 

        CApaWindowGroupName::NewLC(wsSession, (TUint32)&iBackdropWindowGroup);

    apaName->SetHidden(ETrue);

    apaName->SetSystem(ETrue); 

    apaName->SetCaptionL(EIKON_SERVER_BACKDROP_WINDOW_GROUP_NAME);

    User::LeaveIfError(apaName->SetWindowGroupName(iBackdropWindowGroup));

    CleanupStack::PopAndDestroy(); //apaName

    iBackdropWindowGroup.SetOrdinalPosition(1, ECoeWinPriorityNormal);

    // to make sure that wserv does not change our priority even we lose foreground

    wsSession.ComputeMode(RWsSession::EPriorityControlDisabled);

    wsSession.SetDoubleClick(KTimeBetweenClicks,KDoubleClickDistance);

    // AKNLAF

    wsSession.SetKeyboardRepeatRate(KAknKeyboardRepeatInitialDelay, KAknStandardKeyboardRepeatRate); 

    // Disable some of wserv hotkeys if not in RnD mode.

    if (!BaflUtils::FileExists( iEikonEnv->FsSession(), KRDSupport ))

        {

        User::LeaveIfError(wsSession.ClearHotKeys(EHotKeyOfDeath));

        // Symbian already protects this in urel mode, but just to play it safe  

        User::LeaveIfError(wsSession.ClearHotKeys(EHotKeyShutDown)); 

        User::LeaveIfError(wsSession.ClearHotKeys(EHotKeyOff));       

        }

    // Create statuspane & SGcs

    if (iEikonEnv->StatusPaneCoreResId())

        {

        iStatusPane = CEikServStatusPane::NewL(

            *iEikonEnv, 

            &iBackdropWindowGroup, 

            iEikonEnv->StatusPaneCoreResId());

        }

    iSgcs = CEikSgcServer::NewL();

    iSgcs->SetStatusPane(iStatusPane);

    iSgcs->SetAknCapAppServerAppUi(this);

    RWindowGroup& rootWin = iCoeEnv->RootWin();

    rootWin.EnableGroupListChangeEvents();

    rootWin.EnableScreenChangeEvents();

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

    iSgcs->HandleWindowGroupParamChangeL(rootWin.Identifier(), EFalse, 0, 0, KAknScreenModeUnset);

    // create a high priority key filter

    // i.e. capture Apps-Key

    iKeyCaptureControl=new(ELeave) CAknServKeyFilter();

    iKeyCaptureControl->ConstructL(*this);

    TFileName fileName(KEikSrvUIResFileName);

    BaflUtils::NearestLanguageFile(iEikonEnv->FsSession(),fileName);

    iResourceFileOffset=iCoeEnv->AddResourceFileL(fileName);

    // MMC unlocker

    iMMCUnlock = CAknMMCPasswordRequester::NewL();

    // Boost our priority similar to eikon server.

    RThread thread; 

#if defined(__EPOC32__)

    thread.SetProcessPriority(EPriorityHigh);

#else

    thread.SetPriority(EPriorityAbsoluteForeground);

#endif

    // Start OOM watcher thread when scheduler is running

    // effectively this frees eikon server thread also.

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

    iIdler->Start(TCallBack(StartOOM, this));

    SetAliasKeyCodeResolverL(this);       

    // Define the property for Idle application window group id. This cannot be done in AknIcon,

    // because the property is internal in classicui domain.

    TInt err = RProperty::Define(

        KPSUidAvkonInternal, 

        KAknIdleAppWindowGroupId, 

        RProperty::EInt, 

        KPassReadPolicy,  // None

        KWriteDDPolicy);  // WriteDeviceData

    if (err != KErrAlreadyExists)

        {

        User::LeaveIfError(err);

        }

    // Define a PubSub key indicate menu option has the task swapper item or not

    err =  RProperty::Define(

    KPSUidAvkonInternal, 

    KAknMenuOptionNoTaskSwapper, 

    RProperty::EInt); 

    if ( err != KErrNone && err != KErrAlreadyExists )

         {

         User::LeaveIfError( err );

         } 

#ifdef RD_INTELLIGENT_TEXT_INPUT        

    // Define the property for Idle application window group id. This cannot be done in AknIcon,

    // because the property is internal in classicui domain.

    err = RProperty::Define(

        KPSUidAknFep, 

        KAknFepFnKeyState, 

        RProperty::EInt, 

        KPassReadPolicy,  // None

        KWriteDDPolicy);  // WriteDeviceData

    if (err != KErrAlreadyExists)

        {

        User::LeaveIfError(err);

        }

#endif

    // Start listening "global notes allowed" property. When global notes are allowed,

    // we know that the boot is finished and the Idle app window group id can be fetched.       

    User::LeaveIfError(iGlobalNotesAllowedProperty.Attach(

        KPSUidUikon, 

        KUikGlobalNotesAllowed));        

    iGlobalNotesAllowedSubscriber = new (ELeave) CPropertySubscriber(

        TCallBack(GlobalNotesAllowedCallBack, this), 

        iGlobalNotesAllowedProperty);

    iGlobalNotesAllowedSubscriber->Subscribe();

    // Start listening "telephony idle uid" property.

    User::LeaveIfError(iTelephonyIdleUidProperty.Attach(

        KPSUidAiInformation, 

        KActiveIdleUid));

    iTelephonyIdleUidSubscriber = new (ELeave) CPropertySubscriber(

        TCallBack(TelephonyIdleUidCallBack, this), 

        iTelephonyIdleUidProperty);

    iTelephonyIdleUidSubscriber->Subscribe();    

#ifdef RD_INTELLIGENT_TEXT_INPUT

    TInt err1 = 0;         

    err1 = RProperty::Define(KPtiEnginePSUid, EKeyMapPropertyCount, RProperty::EInt,

                            KCapServerPtiEngineAlwaysPass, KCapServerPtiEngineWritePolicy);

    err1 |= RProperty::Set(KPtiEnginePSUid, EKeyMapPropertyCount, 0);    

    err1 |= RProperty::Define(KPtiEnginePSUid, EKeyMapPropertyData, RProperty::EByteArray,    

                            KCapServerPtiEngineAlwaysPass, KCapServerPtiEngineWritePolicy);

    err1 |= RProperty::Define(KPtiEnginePSUid, EKeyMapPropertyData2, RProperty::EByteArray,

                             KCapServerPtiEngineAlwaysPass, KCapServerPtiEngineWritePolicy);                                           

    err1 |= RProperty::Define(KPtiEnginePSUid, EKeyMapPropertyCount2, RProperty::EInt,

                            KCapServerPtiEngineAlwaysPass, KCapServerPtiEngineWritePolicy);

    err1 |= RProperty::Set(KPtiEnginePSUid, EKeyMapPropertyCount2, 0);      

    err1 |= RProperty::Define(KPtiEnginePSUid, EKeyMapPropertyData3, RProperty::EByteArray,

                             KCapServerPtiEngineAlwaysPass, KCapServerPtiEngineWritePolicy);                                           

    err1 |= RProperty::Define(KPtiEnginePSUid, EKeyMapPropertyCount3, RProperty::EInt,

                            KCapServerPtiEngineAlwaysPass, KCapServerPtiEngineWritePolicy);

    err1 |= RProperty::Set(KPtiEnginePSUid, EKeyMapPropertyCount3, 0);   

   // Create ptiengine instance for key code resolver.

	if (err1 == KErrNone && !iPtiEngine)

   		{   		

   		// create PtiEngine already here because only cap server process has write rights to

   		// above properties and several PtiEngine cores want to cache language

   		// bindings to those properties.

		TRAP_IGNORE(iPtiEngine = CPtiEngine::NewL(ETrue));

	 	}           

#endif

    // Create capserver discreetpopuphandler     

    CAknCapServerDiscreetPopupHandler::CreateDiscreetPopupHandlerL();     

    LoadAlternateFsPlugin();

    // Create FSW

    if ( iAlternateFS == NULL )

        {

        iFSControl= new (ELeave) CAknFastSwapWindowControl(*this);

        iFSControl->ConstructL();

        }

	ProcessInitFlipStatus();

    }

TKeyResponse CAknCapAppServerAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

    {

    return CAknNotifierAppServerAppUi::HandleKeyEventL(aKeyEvent, aType);

    }

// This must not leave if aAddCount == 0.

void CAknCapAppServerAppUi::SuppressAppSwitchingL(TInt aAddCount, TInt aClientId)

    {

    TInt index = KErrNotFound;

    for (TInt ii=0;ii<iAppsKeyArray.Count();ii++)

        {

        if (iAppsKeyArray[ii].iUid == aClientId)

            {

            index = ii;

            }

        }

    if (aAddCount == EAknAppsKeyBlockRemoveClient && aClientId) // client is exiting

        {

        if (index != KErrNotFound)

            {

            iAppsKeyArray.Remove(index);

            }

        return;

        }

    // create client entry (did not previosly exist)

    if (index == KErrNotFound)