/*

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

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eiknotifyalert.h>

#include <viewclipartner.h>

#include <uiklaf/private/pluginuid.hrh>

#endif

#include <hal.h>

#include <hal_data.h>

#include <s32file.h>

#include <basched.h>

#include <bautils.h>

#include <eikdll.h>

#include <eikenv.h>

#include <eikkeys.h>

#include "eikkwin.h"

#include <eikmover.h>

#include <eikon.rsg>

#include <uikon/eiksrvui.h>

#include <eiksvdef.h>

#include <Eikalmct.h>

#define __ASSHDBITFLAGS_H__

#include <uikon/eikalsup.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#include <eikunder.h>

#include <uikon/eikalsrv.h>

#include <uikon/eiknfysv.h>

#include "EIKNFYUI.H"

#include <eiksrvui.rsg>

#include <viewcli.h>

/*

* Following resources used from Symbian's eikpriv.rss file:

* 

* r_eik_system_default_view_id

* r_eik_system_view_server_event_time_out

* r_eik_system_view_server_client_request_time_out

*/

#include <eikpriv.rsg>

#include "EIKSRV.HRH"

#include <aknPopup.h>

#include <avkon.rsg>

#include <eiktxlbx.h>

#include <eiktxlbm.h>

#include "eikkeysoundserver.h"

#include <aknsoundsystem.h>

#include <eikapp.h>

#include <aknenv.h>

#include <AknLayout.lag>

#include <AknUtils.h>

#include <AknsUtils.h>

#include <featmgr.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>    // KUikLayoutState

#include <aknpriv.rsg>

#include <AknDef.h>

#include <AknIconUtils.h>

#include <avkon.mbg>

#include <aknlayout.cdl.h>

#include <asclisession.h>

#include <asclidefinitions.h>

#include <ascliclientutils.h>

#include <c32comm.h>

#include <apasvst.h>

#include <apgcli.h>

#include <apgwgnam.h>

#include <viewcli.h>

#include <vwsappst.h> 

#include "e32uid.h"

#include <eiksrvsp.h>

#include <eiksrvs.h>

#include <akneiksrvs.h>

#include <uiklaf/private/lafenv.h>

#include <uiklaf/private/lafsrv.h>

#include <eikrutil.h>

#include <AknSgcc.h>

#include <aknconsts.h>

#include "EikLafShutStarter.h"

#include "EikLafShutScheduler.h"

#include <AknWsEventObserver.h>

#include <aknappui.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknFontSpecification.h>

#include <AknTextDecorationMetrics.h>

#include <e32capability.h>

#include <AknCapServerDefs.h>

#include <akndialogcontroller.h>

#include "AknNotifierControllerPlugin.h"

#include <AknCustomCursorSupport.h>

#include "AknEikSrv.pan"

#include <hb/hbcore/hbsymbianvariant.h>

#include <hb/hbcore/hbdevicedialogsymbian.h>

#if defined(__WINS__)

const TInt KEikServSideBarWidth = 35;

const TInt KEikServAppbarHeight = 50;

#endif

#if defined (__WINS__)

_LIT(COMMS_PDD_NAME, "ECDRV");

_LIT(COMMS_LDD_NAME, "ECOMM");

#else

_LIT(COMMS_PDD_NAME, "EUART1");

_LIT(COMMS_LDD_NAME, "ECOMM");

#endif

const TInt KEikServServerRestartDelay = 500000; // .5 sec

const TInt KEikServServerRestartInterval = 3000000; // 3 sec

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

_LIT(KAnimDllFileName, "AknAnimDll.Dll");

_LIT(KWatcherThreadName, "UikonWatchers");

const TInt KEikServPanicTextBufferSize = 512;

GLDEF_C void Panic(TEikServPanic aPanic)

    {

    _LIT(KPanicCat,"EIKON-SERVER");

    User::Panic(KPanicCat,aPanic);

    }

#define iAknCapServerClient (*(CAknSgcClient::AknSrv()))

class CFbsBitmap;

// =====================

// RKeySoundServerCloser

// =====================

class RKeySoundServerCloser : public RSessionBase

    {

public:

    void CloseServer();

    };

void RKeySoundServerCloser::CloseServer()

    {

    if (CreateSession(__KEYSOUND_SERVER_NAME, TVersion(KKeySoundServMajorVN, KKeySoundServMinorVN, 

        KKeySoundServBuildVN), 0) == KErrNone)

        {

        SendReceive(EKeySoundServerCloseServer, TIpcArgs());

        Close();

        }

    }

// ==================

// CEikServAppStarter

// ==================

class CEikServAppStarter : public CBase, public MVwsAppStarter

    {

public:

    static CEikServAppStarter* NewL();

    ~CEikServAppStarter();

public: // From MVwsAppStarter.

    void StartAppL(TUid aAppUid, TThreadId& aThreadId);

private:

    CEikServAppStarter();

    void ConstructL();

private:

    };

CEikServAppStarter* CEikServAppStarter::NewL()

    {

    CEikServAppStarter* self=new(ELeave) CEikServAppStarter;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CEikServAppStarter::~CEikServAppStarter()

    {

    }

CEikServAppStarter::CEikServAppStarter()

    {

    }

void CEikServAppStarter::ConstructL()

    {

    }

void CEikServAppStarter::StartAppL(TUid aAppUid, TThreadId& aThreadId)

    {

    RApaLsSession ls;

    CleanupClosePushL(ls);

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

    TApaAppInfo info;

    TInt err = ls.GetAppInfo(info,aAppUid);

    User::LeaveIfError(err);

    // LeaveIfError does not trigger to positive values, but GetAppInfo does not return valid 

    // data unless server returns KErrNone.

    if ( err > 0 ) 

        {         

        User::Leave(KErrNotReady);

        }

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();  

    cmdLine->SetExecutableNameL(info.iFullName);

    cmdLine->SetCommandL(EApaCommandViewActivate);

    // Using apparc client-server to do this "internal" launch.

    ls.StartApp(*cmdLine, aThreadId); 

    CleanupStack::PopAndDestroy(); // cmdLine

    CleanupStack::PopAndDestroy(); // ls

    }

// Thread function for OOD watcher.

GLDEF_C TInt WatcherThreadFunction(TAny* /*aParameters*/)

    {

    TInt err(KErrNone);

    CTrapCleanup* cleanup = CTrapCleanup::New();

    CActiveScheduler* scheduler = new CEikLafShutScheduler();

    CEikLafShutStarter* lafShut = NULL;

    if (!cleanup || !scheduler)

        {

        err = KErrNoMemory;

        }

    else

        {

        CActiveScheduler::Install(scheduler);

        TRAP(err, 

            {

            RThread me;

            me.SetPriority(EPriorityLess);

            lafShut = CEikLafShutStarter::NewL();

            })

        if (err == KErrNone)

            {

            // start the watchers

            CActiveScheduler::Start();

            }

        }

    delete cleanup;

    delete scheduler;

    delete lafShut;

    return err;

    }

// Creates thread for OOM & OOD watchers.

GLDEF_C void CreateWatcherThreadL()

    {

    RThread thread;

    TInt ret = thread.Create( 

        KWatcherThreadName, 

        WatcherThreadFunction,

        0x2000,                 // stack size

        NULL,                   // uses caller thread's heap

        (TAny*)NULL );

    if (ret == KErrNone)

        {

        thread.Resume();

        thread.Close();

        }

    User::LeaveIfError(ret);

    }

// ==================

// CEikSrvAppShutdown

// ==================

NONSHARABLE_CLASS(CEikSrvAppShutdown) : public CActive

    {

public:

    static void StartL(

        const TUid aRequesterUID, 

        const RMessage2& aShutdownMessage, 

        const TInt aTimeoutInMicroseconds);

private:

    CEikSrvAppShutdown(const RMessage2& aShutdownMessage);

    ~CEikSrvAppShutdown();

    void DoCancel();

    void RunL();

private:

    RMessagePtr2 iMessage;

    };

void CEikSrvAppShutdown::StartL(const TUid aRequesterUID, const RMessage2& aShutdownMessage,

    const TInt aTimeoutInMicroseconds)

    {

    if (iAknCapServerClient.Handle())

        {

        CEikSrvAppShutdown* self = new(ELeave) CEikSrvAppShutdown(aShutdownMessage);

        iAknCapServerClient.ShutdownApps(aRequesterUID, aTimeoutInMicroseconds, self->iStatus);

        self->SetActive();

        }

    else

        aShutdownMessage.Complete(KErrNone);

    }

CEikSrvAppShutdown::CEikSrvAppShutdown(const RMessage2& aShutdownMessage)

: CActive(CActive::EPriorityStandard), iMessage(aShutdownMessage)

    {

    CActiveScheduler::Add(this);

    }

CEikSrvAppShutdown::~CEikSrvAppShutdown()

    {

    Cancel();

    }

void CEikSrvAppShutdown::DoCancel()

    {

    }

void CEikSrvAppShutdown::RunL()

    {

    iMessage.Complete(KErrNone);

    delete this;

    }

// =============

// CEikServExtra

// =============

class CEikServExtra : public CBase

    {

public:

    CPeriodic* iServerRestarter;

    CArrayPtr<RWsPointerCursor>* iPointerCursors;

    CIdle* iNotifierServerStarter;

    };

const TInt KEiksrvUiDllValue = 0x100053D0;

EXPORT_C CEikServAppUiBase* CEikServAppUiBase::NewLC()

    {

    if (CEikonEnv::Static()->WsSession().FindWindowGroupIdentifier(

        0, __EIKON_SERVER_NAME, 0) > KErrNotFound)

        {

        return NULL; // Already an Eikon server running.

        }

    // This code duplicates what is in EikSrv.cpp in CEikServAppUiServer::CreateAppUiL().

    _LIT(KRomPath, "\\System\\Libs\\");

    _LIT(KEiksrvUiDllName, "EiksrvUi.dll");

    TFileName path;

    Dll::FileName(path);

    const TUint16& drv = path[0];

    if (drv == 'z' || drv == 'Z')

        {

        path.Append(KRomPath);

        }

    else

        {

        TParse parse;

        User::LeaveIfError(parse.Set(path, NULL, NULL));

        path = parse.DriveAndPath();

        }

    TUidType uidType(KDynamicLibraryUid, KSharedLibraryUid, TUid::Uid(KEiksrvUiDllValue));

    RLibrary lib;

    User::LeaveIfError(lib.Load(KEiksrvUiDllName, path, uidType));

    CleanupClosePushL(lib);

    TLibraryFunction appui = lib.Lookup(1);

    CEikServAppUiBase* self = REINTERPRET_CAST(CEikServAppUiBase*, (*appui)());

    User::LeaveIfNull(self);

    STATIC_CAST(CEikServEnv*, CEikonEnv::Static())->SetUiDll(lib);

    CleanupStack::Pop(); // lib

    CleanupStack::PushL(self);

    STATIC_CAST(CEikAppUi*, self)->ConstructL();

    return self;

    }

EXPORT_C void CEikServAppUiBase::NotifyAlarmServerOfTaskChangeL()

    {

    if (iAlarmAlertServer)

        {

        iAlarmAlertServer->TaskKeyPressedL();

        }

    }

EXPORT_C void CEikServAppUiBase::EnableTaskListL()

    {

    User::Leave(KErrNotSupported);

    }

EXPORT_C void CEikServAppUiBase::LaunchTaskListL()

    {

    User::Leave(KErrNotSupported);

    }

EXPORT_C void CEikServAppUiBase::CycleTasksL(enum TTaskCycleDirection aDirection) 

    {

    TApaTaskList taskList(iCoeEnv->WsSession());

    if (aDirection == EBackwards)

        {

        TApaTask task = taskList.FindByPos(-1);

        task.BringToForeground();

        }

    else

        {

        TApaTask task = taskList.FindByPos(0);

        task.SendToBackground();

        }

    // Will also task away from alarm when only 1 task!! Correct?        

    NotifyAlarmServerOfTaskChangeL(); 

    }

EXPORT_C CEikServAppUiBase::CEikServAppUiBase()

    {

    SetFullScreenApp(EFalse);

    }

LOCAL_C void ReleaseFactories(TAny* aPtr)

    {

    TEikServCtrlFactories& factory = *(TEikServCtrlFactories*)aPtr;

    if (factory.iAlert)

        {

        factory.iAlert->Release();

        }

    }

LOCAL_C void PointerCleanup(TAny* aPtr)

    {

    RWsPointerCursor* ptr = REINTERPRET_CAST(RWsPointerCursor*, aPtr);

    ptr->Close();

    delete ptr;

    }

EXPORT_C void CEikServAppUiBase::ConstructL() 

    {

    RWindowGroup& groupWin = iCoeEnv->RootWin();

    RWsSession& wsSession = iCoeEnv->WsSession();

    iEikonEnv->SetAutoForwarding(ETrue);

    iEikonEnv->SetSystem(ETrue);

    iEikonEnv->FsSession().SetNotifyUser(EFalse);

    // Must call BaseConstructL to get Avkon classes called.

#ifdef _DEBUG

    RDebug::Print(_L("CAknAppUiBase::BaseConstructL() in "));

#endif

    CAknAppUiBase::BaseConstructL(ENonStandardResourceFile|ENoScreenFurniture|

        EAknEnableMSK|EAknSingleClickCompatible);

#ifdef _DEBUG

    RDebug::Print(_L("CAknAppUiBase::BaseConstructL() out"));

#endif

    groupWin.SetName(__EIKON_SERVER_NAME);

    groupWin.EnableErrorMessages(EEventControlAlways);

    groupWin.EnableOnEvents(EEventControlAlways);

    wsSession.ComputeMode(RWsSession::EPriorityControlDisabled);

    iCoeEnv->RootWin().EnableScreenChangeEvents();

    RThread thread;

#if defined(__EPOC32__)

    thread.SetProcessPriority(EPriorityHigh);

#else

    thread.SetPriority(EPriorityAbsoluteForeground);

#endif

    // Create a window group for the password and alarm screens.

    iAlertGroupWin = RWindowGroup(wsSession);

    // EFalse disables key events - they will be enabled again as soon as the ordinal position is 

    // set such that iAlertGroupWin is not the foreground window-group.

    User::LeaveIfError(iAlertGroupWin.Construct((TUint32)this, EFalse)); 

    iAlertGroupWin.SetOrdinalPosition(0, ECoeWinPriorityNeverAtFront);

    // Enable key events, now that iAlertGroupWin is not in the foreground.

    iAlertGroupWin.EnableReceiptOfFocus(ETrue); 

    iEikServExtra = new(ELeave) CEikServExtra();

    TInt numCursors = LafServAppUiBase::NumberOfCursorsInSystemCursorList();

    if(numCursors != 0 && LafServAppUiBase::ClaimPointerCursorListIfNeeded(*iEikonEnv) == KErrNone)

        {

        iEikServExtra->iPointerCursors = new(ELeave) CArrayPtrFlat<RWsPointerCursor>(4);

        TSpriteMember member;

        for(TInt ii = 0; ii < numCursors; ii++)

            {

            RWsPointerCursor* cursor = LafServAppUiBase::ConstructPointerCursorL(ii, member, 

                *iEikonEnv);

            CleanupStack::PushL(TCleanupItem(PointerCleanup, cursor));

            iEikServExtra->iPointerCursors->AppendL(cursor);