1 /*

     2 * Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  

    15 *

    16 */

    17 

    18 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    19 #include <uikon/eiknotifyalert.h>

    20 #include <viewclipartner.h>

    21 #include <uiklaf/private/pluginuid.hrh>

    22 #endif

    23 #include <hal.h>

    24 #include <hal_data.h>

    25 #include <s32file.h>

    26 #include <basched.h>

    27 #include <bautils.h>

    28 #include <eikdll.h>

    29 #include <eikenv.h>

    30 #include <eikkeys.h>

    31 #include "eikkwin.h"

    32 #include <eikmover.h>

    33 #include <eikon.rsg>

    34 

    35 #include <uikon/eiksrvui.h>

    36 #include <eiksvdef.h>

    37 #include <Eikalmct.h>

    38 

    39 #define __ASSHDBITFLAGS_H__

    40 

    41 #include <uikon/eikalsup.h>

    42 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    43 #include <uikon/eikenvinterface.h>

    44 #endif

    45 #include <eikunder.h>

    46 #include <uikon/eikalsrv.h>

    47 #include <uikon/eiknfysv.h>

    48 #include "EIKNFYUI.H"

    49 #include <eiksrvui.rsg>

    50 #include <viewcli.h>

    51 

    52 /*

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

    54 * 

    55 * r_eik_system_default_view_id

    56 * r_eik_system_view_server_event_time_out

    57 * r_eik_system_view_server_client_request_time_out

    58 */

    59 #include <eikpriv.rsg>

    60 #include "EIKSRV.HRH"

    61 

    62 #include <aknPopup.h>

    63 #include <avkon.rsg>

    64 #include <eiktxlbx.h>

    65 #include <eiktxlbm.h>

    66 #include "eikkeysoundserver.h"

    67 #include <aknsoundsystem.h>

    68 #include <eikapp.h>

    69 #include <aknenv.h>

    70 

    71 #include <AknLayout.lag>

    72 #include <AknUtils.h>

    73 #include <AknsUtils.h>

    74 #include <featmgr.h>

    75 

    76 #include <e32property.h>

    77 #include <UikonInternalPSKeys.h>    // KUikLayoutState

    78 

    79 #include <aknpriv.rsg>

    80 #include <AknDef.h>

    81 

    82 #include <AknIconUtils.h>

    83 #include <avkon.mbg>

    84 #include <aknlayout.cdl.h>

    85 

    86 #include <asclisession.h>

    87 #include <asclidefinitions.h>

    88 #include <ascliclientutils.h>

    89 #include <c32comm.h>

    90 

    91 #include <apasvst.h>

    92 #include <apgcli.h>

    93 #include <apgwgnam.h>

    94 #include <viewcli.h>

    95 #include <vwsappst.h> 

    96 

    97 #include "e32uid.h"

    98 

    99 #include <eiksrvsp.h>

   100 #include <eiksrvs.h>

   101 #include <akneiksrvs.h>

   102 

   103 #include <uiklaf/private/lafenv.h>

   104 #include <uiklaf/private/lafsrv.h>

   105 

   106 #include <eikrutil.h>

   107 #include <AknSgcc.h>

   108 #include <aknconsts.h>

   109 

   110 #include "EikLafShutStarter.h"

   111 #include "EikLafShutScheduler.h"

   112 

   113 #include <AknWsEventObserver.h>

   114 #include <aknappui.h>

   115 #include <aknlayoutscalable_avkon.cdl.h>

   116 #include <AknFontSpecification.h>

   117 #include <AknTextDecorationMetrics.h>

   118 #include <e32capability.h>

   119 

   120 #include <AknCapServerDefs.h>

   121 #include <akndialogcontroller.h>

   122 

   123 #include "AknNotifierControllerPlugin.h"

   124 #include <AknCustomCursorSupport.h>

   125 #include "AknEikSrv.pan"

   126 

   127 #if defined(__WINS__)

   128 const TInt KEikServSideBarWidth = 35;

   129 const TInt KEikServAppbarHeight = 50;

   130 #endif

   131 

   132 #if defined (__WINS__)

   133 _LIT(COMMS_PDD_NAME, "ECDRV");

   134 _LIT(COMMS_LDD_NAME, "ECOMM");

   135 #else

   136 _LIT(COMMS_PDD_NAME, "EUART1");

   137 _LIT(COMMS_LDD_NAME, "ECOMM");

   138 #endif

   139 

   140 const TInt KEikServServerRestartDelay = 500000; // .5 sec

   141 const TInt KEikServServerRestartInterval = 3000000; // 3 sec

   142 

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

   144 _LIT(KAnimDllFileName, "AknAnimDll.Dll");

   145 _LIT(KWatcherThreadName, "UikonWatchers");

   146 

   147 const TInt KEikServPanicTextBufferSize = 512;

   148 

   149 GLDEF_C void Panic(TEikServPanic aPanic)

   150     {

   151     _LIT(KPanicCat,"EIKON-SERVER");

   152     User::Panic(KPanicCat,aPanic);

   153     }

   154 

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

   156 

   157 class CFbsBitmap;

   158 

   159 // =====================

   160 // RKeySoundServerCloser

   161 // =====================

   162 

   163 class RKeySoundServerCloser : public RSessionBase

   164     {

   165 public:

   166     void CloseServer();

   167     };

   168 

   169 void RKeySoundServerCloser::CloseServer()

   170     {

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

   172         KKeySoundServBuildVN), 0) == KErrNone)

   173         {

   174         SendReceive(EKeySoundServerCloseServer, TIpcArgs());

   175         Close();

   176         }

   177     }

   178 

   179 // ==================

   180 // CEikServAppStarter

   181 // ==================

   182 

   183 class CEikServAppStarter : public CBase, public MVwsAppStarter

   184     {

   185 public:

   186     static CEikServAppStarter* NewL();

   187     ~CEikServAppStarter();

   188 public: // From MVwsAppStarter.

   189     void StartAppL(TUid aAppUid, TThreadId& aThreadId);

   190 private:

   191     CEikServAppStarter();

   192     void ConstructL();

   193 private:

   194     };

   195 

   196 CEikServAppStarter* CEikServAppStarter::NewL()

   197     {

   198     CEikServAppStarter* self=new(ELeave) CEikServAppStarter;

   199     CleanupStack::PushL(self);

   200     self->ConstructL();

   201     CleanupStack::Pop();

   202     return self;

   203     }

   204 

   205 CEikServAppStarter::~CEikServAppStarter()

   206     {

   207     }

   208 

   209 CEikServAppStarter::CEikServAppStarter()

   210     {

   211     }

   212 

   213 void CEikServAppStarter::ConstructL()

   214     {

   215     }

   216 

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

   218     {

   219     RApaLsSession ls;

   220     CleanupClosePushL(ls);

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

   222     TApaAppInfo info;

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

   224 

   225     User::LeaveIfError(err);

   226     

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

   228     // data unless server returns KErrNone.

   229     if ( err > 0 ) 

   230         {         

   231         User::Leave(KErrNotReady);

   232         }

   233 

   234     CApaCommandLine* cmdLine = CApaCommandLine::NewLC();  

   235     cmdLine->SetExecutableNameL(info.iFullName);

   236     cmdLine->SetCommandL(EApaCommandViewActivate);

   237     

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

   239     ls.StartApp(*cmdLine, aThreadId); 

   240     CleanupStack::PopAndDestroy(); // cmdLine

   241     CleanupStack::PopAndDestroy(); // ls

   242     }

   243 

   244 // Thread function for OOD watcher.

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

   246     {

   247     TInt err(KErrNone);

   248 

   249     CTrapCleanup* cleanup = CTrapCleanup::New();

   250     CActiveScheduler* scheduler = new CEikLafShutScheduler();

   251     CEikLafShutStarter* lafShut = NULL;

   252 

   253     if (!cleanup || !scheduler)

   254         {

   255         err = KErrNoMemory;

   256         }

   257 

   258     else

   259         {

   260         CActiveScheduler::Install(scheduler);

   261         TRAP(err, 

   262             {

   263             RThread me;

   264             me.SetPriority(EPriorityLess);

   265             lafShut = CEikLafShutStarter::NewL();

   266             })

   267 

   268         if (err == KErrNone)

   269             {

   270             // start the watchers

   271             CActiveScheduler::Start();

   272             }

   273         }

   274 

   275     delete cleanup;

   276     delete scheduler;

   277     delete lafShut;

   278     

   279     return err;

   280     }

   281 

   282 // Creates thread for OOM & OOD watchers.

   283 GLDEF_C void CreateWatcherThreadL()

   284     {

   285     RThread thread;

   286 

   287     TInt ret = thread.Create( 

   288         KWatcherThreadName, 

   289         WatcherThreadFunction,

   290         0x2000,                 // stack size

   291         NULL,                   // uses caller thread's heap

   292         (TAny*)NULL );

   293 

   294     if (ret == KErrNone)

   295         {

   296         thread.Resume();

   297         thread.Close();

   298         }

   299 

   300     User::LeaveIfError(ret);

   301     }

   302 

   303 // ==================

   304 // CEikSrvAppShutdown

   305 // ==================

   306 

   307 NONSHARABLE_CLASS(CEikSrvAppShutdown) : public CActive

   308     {

   309 public:

   310     static void StartL(

   311         const TUid aRequesterUID, 

   312         const RMessage2& aShutdownMessage, 

   313         const TInt aTimeoutInMicroseconds);

   314 private:

   315     CEikSrvAppShutdown(const RMessage2& aShutdownMessage);

   316     ~CEikSrvAppShutdown();

   317     void DoCancel();

   318     void RunL();

   319 private:

   320     RMessagePtr2 iMessage;

   321     };

   322 

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

   324     const TInt aTimeoutInMicroseconds)

   325     {

   326     if (iAknCapServerClient.Handle())

   327         {

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

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

   330         self->SetActive();

   331         }

   332     else

   333         aShutdownMessage.Complete(KErrNone);

   334     }

   335 

   336 CEikSrvAppShutdown::CEikSrvAppShutdown(const RMessage2& aShutdownMessage)

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

   338     {

   339     CActiveScheduler::Add(this);

   340     }

   341 

   342 CEikSrvAppShutdown::~CEikSrvAppShutdown()

   343     {

   344     Cancel();

   345     }

   346 

   347 void CEikSrvAppShutdown::DoCancel()

   348     {

   349     }

   350 

   351 void CEikSrvAppShutdown::RunL()

   352     {

   353     iMessage.Complete(KErrNone);

   354     delete this;

   355     }

   356 

   357 // =============

   358 // CEikServExtra

   359 // =============

   360 

   361 class CEikServExtra : public CBase

   362     {

   363 public:

   364     CPeriodic* iServerRestarter;

   365     CArrayPtr<RWsPointerCursor>* iPointerCursors;

   366     CIdle* iNotifierServerStarter;

   367     };

   368 

   369 const TInt KEiksrvUiDllValue = 0x100053D0;

   370 

   371 

   372 EXPORT_C CEikServAppUiBase* CEikServAppUiBase::NewLC()

   373     {

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

   375         0, __EIKON_SERVER_NAME, 0) > KErrNotFound)

   376         {

   377         return NULL; // Already an Eikon server running.

   378         }

   379 

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

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

   382     _LIT(KEiksrvUiDllName, "EiksrvUi.dll");

   383     TFileName path;

   384     Dll::FileName(path);

   385     const TUint16& drv = path[0];

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

   387         {

   388         path.Append(KRomPath);

   389         }

   390     else

   391         {

   392         TParse parse;

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

   394         path = parse.DriveAndPath();

   395         }

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

   397     RLibrary lib;

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

   399     CleanupClosePushL(lib);

   400     TLibraryFunction appui = lib.Lookup(1);

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

   402     User::LeaveIfNull(self);

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

   404     CleanupStack::Pop(); // lib

   405     CleanupStack::PushL(self);

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

   407 

   408     return self;

   409     }

   410 

   411 EXPORT_C void CEikServAppUiBase::NotifyAlarmServerOfTaskChangeL()

   412     {

   413     if (iAlarmAlertServer)

   414         {

   415         iAlarmAlertServer->TaskKeyPressedL();

   416         }

   417     }

   418 

   419 EXPORT_C void CEikServAppUiBase::EnableTaskListL()

   420     {

   421     User::Leave(KErrNotSupported);

   422     }

   423 

   424 EXPORT_C void CEikServAppUiBase::LaunchTaskListL()

   425     {

   426     User::Leave(KErrNotSupported);

   427     }

   428 

   429 EXPORT_C void CEikServAppUiBase::CycleTasksL(enum TTaskCycleDirection aDirection) 

   430     {

   431     TApaTaskList taskList(iCoeEnv->WsSession());

   432     if (aDirection == EBackwards)

   433         {

   434         TApaTask task = taskList.FindByPos(-1);

   435         task.BringToForeground();

   436         }

   437     else

   438         {

   439         TApaTask task = taskList.FindByPos(0);

   440         task.SendToBackground();

   441         }

   442     

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

   444     NotifyAlarmServerOfTaskChangeL(); 

   445     }

   446 

   447 EXPORT_C CEikServAppUiBase::CEikServAppUiBase()

   448     {

   449     SetFullScreenApp(EFalse);

   450     }

   451 

   452 LOCAL_C void ReleaseFactories(TAny* aPtr)

   453     {

   454     TEikServCtrlFactories& factory = *(TEikServCtrlFactories*)aPtr;

   455     if (factory.iAlert)

   456         {

   457         factory.iAlert->Release();

   458         }

   459     }

   460 

   461 LOCAL_C void PointerCleanup(TAny* aPtr)

   462     {

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

   464     ptr->Close();

   465     delete ptr;

   466     }

   467 

   468 EXPORT_C void CEikServAppUiBase::ConstructL() 

   469     {

   470     RWindowGroup& groupWin = iCoeEnv->RootWin();

   471     RWsSession& wsSession = iCoeEnv->WsSession();

   472     iEikonEnv->SetAutoForwarding(ETrue);

   473     iEikonEnv->SetSystem(ETrue);

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

   475 

   476     // Must call BaseConstructL to get Avkon classes called.

   477 #ifdef _DEBUG

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

   479 #endif

   480     CAknAppUiBase::BaseConstructL(ENonStandardResourceFile|ENoScreenFurniture|

   481         EAknEnableMSK|EAknSingleClickCompatible);

   482 #ifdef _DEBUG

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

   484 #endif

   485 

   486     groupWin.SetName(__EIKON_SERVER_NAME);

   487     groupWin.EnableErrorMessages(EEventControlAlways);

   488     groupWin.EnableOnEvents(EEventControlAlways);

   489     wsSession.ComputeMode(RWsSession::EPriorityControlDisabled);

   490     iCoeEnv->RootWin().EnableScreenChangeEvents();

   491     RThread thread;

   492     

   493 #if defined(__EPOC32__)

   494     thread.SetProcessPriority(EPriorityHigh);

   495 #else

   496     thread.SetPriority(EPriorityAbsoluteForeground);

   497 #endif

   498 

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

   500     iAlertGroupWin = RWindowGroup(wsSession);

   501     

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

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

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

   505     

   506     iAlertGroupWin.SetOrdinalPosition(0, ECoeWinPriorityNeverAtFront);

   507     

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

   509     iAlertGroupWin.EnableReceiptOfFocus(ETrue); 

   510 

   511     iEikServExtra = new(ELeave) CEikServExtra();

   512     

   513     TInt numCursors = LafServAppUiBase::NumberOfCursorsInSystemCursorList();

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

   515         {

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

   517         TSpriteMember member;

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

   519             {

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

   521                 *iEikonEnv);

   522                 

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

   524             iEikServExtra->iPointerCursors->AppendL(cursor);

   525             CleanupStack::Pop(); // cursor - handle & ptr

   526             }

   527         }

   528     }

   529 

   530 EXPORT_C void CEikServAppUiBase::InitializeL(TEikServCtrlFactories& aCtrlFactories)

   531     {

   532     RWindowGroup& rootWin = iCoeEnv->RootWin();

   533 

   534     CleanupStack::PushL(TCleanupItem(&ReleaseFactories,&aCtrlFactories));

   535     RFs& fsSession = iCoeEnv->FsSession();

   536     _LIT(KAppDirName, "C:\\System\\Apps\\");

   537     fsSession.MkDirAll(KAppDirName); // !! prevent app arch crash

   538 

   539     // Initialize some system settings.

   540     SetSystemTime();

   541     rootWin.EnableOnEvents(EEventControlAlways);

   542 

   543     TPasswordMode mode = EPasswordNone;

   544 

   545     TRAP_IGNORE(

   546         CEikPasswordModeCategory* pcategory = CEikPasswordModeCategory::NewLC(fsSession);

   547         if( pcategory )

   548             {

   549             pcategory->GetPasswordModeL(mode);

   550             if (mode == EPasswordNone) // prevent overwriting once per day

   551                 {

   552                 mode = EPasswordAlways;    

   553                 }

   554             // Initialise (write to system.ini) here so that it won't fail in the future due to OOM.

   555             pcategory->SetPasswordModeL(mode);

   556             CleanupStack::PopAndDestroy(); // pcategory

   557             }

   558         );

   559 

   560     // Create separate thread for OOD watchers.

   561     CreateWatcherThreadL();

   562 

   563     // Start View Server.

   564     iAppStarter = CEikServAppStarter::NewL();

   565     User::LeaveIfError(CVwsSessionWrapper::StartViewServer(*iAppStarter));

   566     iVwsSession = CVwsSessionWrapper::NewL();

   567     

   568     TResourceReader reader;

   569     iEikonEnv->CreateResourceReaderLC(reader, R_EIK_SYSTEM_DEFAULT_VIEW_ID);

   570     TVwsViewId viewId;

   571     viewId.iAppUid.iUid = reader.ReadInt32();

   572     viewId.iViewUid.iUid = reader.ReadInt32();

   573     CleanupStack::PopAndDestroy(); // reader

   574     iVwsSession->SetSystemDefaultView(viewId);

   575 

   576     TInt serverEventTimeOutDuration = EikResourceUtils::ReadTInt32L(    

   577         R_EIK_SYSTEM_VIEW_SERVER_EVENT_TIME_OUT, iEikonEnv);

   578         

   579     iVwsSession->SetServerEventTimeOut( TTimeIntervalMicroSeconds32(serverEventTimeOutDuration) );

   580     

   581     TInt clientRequestTimeOutDuration = EikResourceUtils::ReadTInt32L(

   582         R_EIK_SYSTEM_VIEW_SERVER_CLIENT_REQUEST_TIME_OUT, iEikonEnv);

   583         

   584     iVwsSession->SetClientRequestTimeOut( TTimeIntervalMicroSeconds32(clientRequestTimeOutDuration) );

   585 

   586     iVwsSession->EnableServerBlankScreen(EFalse);

   587     

   588     // Start Comms

   589     TInt err = StartC32();

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

   591         {

   592         User::Leave(err);

   593         }

   594     

   595     err = User::LoadPhysicalDevice(COMMS_PDD_NAME);

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

   597         {

   598         User::Leave(err);

   599         }

   600         

   601     err = User::LoadLogicalDevice(COMMS_LDD_NAME);

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

   603         {

   604         User::Leave(err);

   605         }

   606 

   607     // Start notifier server last as these may have plug-ins that rely on the other servers 

   608     // started here being up and running.

   609     iNotifyServer = CEikServNotifyServer::NewL(aCtrlFactories.iAlert);

   610 

   611     CleanupStack::Pop(); // aCtrlFactories

   612 

   613     iEikServExtra->iNotifierServerStarter = CIdle::NewL(CActive::EPriorityLow);

   614     iEikServExtra->iNotifierServerStarter->Start(TCallBack(StartNotifierServerCallBackL, this));

   615 

   616     rootWin.EnableGroupListChangeEvents();

   617 

   618     // Create undertaker active object.

   619     iUndertaker = CEikUndertaker::NewL(*this);

   620 

   621     // Create an active object to restart servers. 

   622     iEikServExtra->iServerRestarter = CPeriodic::NewL(CActive::EPriorityStandard);

   623     }

   624 

   625 EXPORT_C void CEikServAppUiBase::HandleThreadExitL(RThread& aThread)

   626     {

   627     if (aThread.Name() == ASCliDefinitions::ServerAndThreadName()) // alarm server died

   628         {

   629         aThread.Close(); // need to Close() before restarting with same name

   630         iServerToRestart |= EAlwlSvr; // restarted under active object

   631         }

   632     else if (aThread.Name()==NameApaServServerThread()) // AppArc server died

   633         {

   634         aThread.Close();

   635         iServerToRestart|=EApaSvr;

   636         }

   637         

   638     if (iServerToRestart && !iEikServExtra->iServerRestarter->IsActive())

   639         {

   640         iEikServExtra->iServerRestarter->Start(

   641             KEikServServerRestartDelay, 

   642             KEikServServerRestartInterval, 

   643             TCallBack(RestartServerCallback, this));

   644         }

   645     }

   646 

   647 EXPORT_C void CEikServAppUiBase::HandleForegroundEventL(TBool aForeground)

   648     {

   649     CAknAppUiBase::HandleForegroundEventL(aForeground);

   650     }

   651 

   652 TInt CEikServAppUiBase::RestartServerCallback(TAny* aObj)

   653     {

   654     STATIC_CAST(CEikServAppUiBase*, aObj)->RestartServer();

   655     return KErrNone;

   656     }

   657 

   658 TInt CEikServAppUiBase::StartNotifierServerCallBackL(TAny* aPtr)

   659     { // static

   660     CEikServAppUiBase* self = static_cast<CEikServAppUiBase*>(aPtr);

   661     self->iNotifyServer->StartL();

   662     delete self->iEikServExtra->iNotifierServerStarter;

   663     self->iEikServExtra->iNotifierServerStarter=NULL;

   664     return KErrNone;

   665     }

   666 

   667 // Kick dead servers back to life, if we can connect then stop kicking.

   668 void CEikServAppUiBase::RestartServer()

   669     {

   670     if (iServerToRestart & EAlwlSvr)

   671         {

   672         // Start AlarmServer

   673         TInt err = AlarmClientUtils::StartAlarmServer();

   674         if (err == KErrNone)

   675             {

   676             iServerToRestart&=(~EAlwlSvr);

   677             }

   678         }

   679         

   680     if (iServerToRestart&EApaSvr)

   681         {

   682         AknStartupApaServerProcess();

   683 

   684         // try to connect to the server

   685         RApaLsSession ls;

   686         TInt err = ls.Connect();

   687         if (err == KErrNone)

   688             {

   689             ls.Close();

   690             iServerToRestart&=(~EApaSvr);

   691             }

   692         }

   693         

   694     if (!iServerToRestart)

   695         {

   696         iEikServExtra->iServerRestarter->Cancel();

   697         }

   698     }

   699 

   700 EXPORT_C TKeyResponse CEikServAppUiBase::HandleKeyEventL(const TKeyEvent& aKeyEvent, 

   701     TEventCode /*aType*/)

   702     {

   703     if (aKeyEvent.iCode == CTRL('e'))

   704         {

   705         CBaActiveScheduler::Exit();

   706         }

   707     return EKeyWasConsumed;

   708     }

   709 

   710 // Check the battery states and update any alarm snooze time.

   711 EXPORT_C void CEikServAppUiBase::HandleSwitchOnEventL(CCoeControl* /*aDestination*/)

   712     {

   713     // Could just expose alarm alert server to UI dll!!

   714     if (iAlarmAlertServer)

   715         {

   716         iAlarmAlertServer->HandleSwitchOnEvent();

   717         }

   718     }

   719 

   720 EXPORT_C void CEikServAppUiBase::HandleSystemEventL(const TWsEvent& aEvent)

   721     {

   722     TInt event = *((TInt*)aEvent.EventData());

   723     switch (event)

   724         {

   725 #ifdef _DEBUG

   726         case EEikServExit:

   727             CBaActiveScheduler::Exit();

   728             break;

   729 #endif

   730         default:

   731             break;

   732         }

   733     }

   734 

   735 EXPORT_C void CEikServAppUiBase::HandleApplicationSpecificEventL(TInt aType, const TWsEvent& aEvent)

   736     {

   737     // Check command/number or whatever first!!

   738     CAknAppUiBase::HandleApplicationSpecificEventL(aType, aEvent);

   739     }

   740 

   741 

   742 EXPORT_C CEikServAppUiBase::~CEikServAppUiBase()

   743     {

   744     delete iUndertaker;

   745     

   746     if (iEikServExtra)

   747         {

   748         delete iEikServExtra->iServerRestarter;

   749         

   750         if (iEikServExtra->iPointerCursors)

   751             {

   752             const TInt count = iEikServExtra->iPointerCursors->Count();

   753             

   754             for (TInt ii = 0; ii < count; ii++)

   755                 {

   756                 (*(iEikServExtra->iPointerCursors))[ii]->Close();

   757                 }

   758                 

   759             iEikServExtra->iPointerCursors->ResetAndDestroy();

   760             delete iEikServExtra->iPointerCursors;

   761             }

   762             

   763         delete iEikServExtra->iNotifierServerStarter;

   764         delete iEikServExtra;

   765         }

   766         

   767     LafServAppUiBase::FreePointerCursorListIfNeeded(*iEikonEnv);

   768     RWindowGroup& groupWin = iEikonEnv->RootWin();

   769     groupWin.DisableErrorMessages();

   770     groupWin.DisableOnEvents();

   771     iAlertGroupWin.Close();

   772     delete iNotifyServer;

   773     delete iAlarmAlertServer;

   774     delete iAppStarter;

   775     

   776     if (iVwsSession)

   777         {

   778         iVwsSession->ShutdownViewServer();

   779         delete iVwsSession;

   780         }

   781     }

   782 

   783 void CEikServAppUiBase::SetSystemTime() const

   784     {

   785     // Deprecated, we don't have capability to set system time.

   786     }

   787 

   788 // Bring to foreground or send to background appropriately.

   789 EXPORT_C void CEikServAppUiBase::BringAlertGroupWinForwards(TBool aForwards)

   790     {

   791     if (aForwards)

   792         {

   793         if (!iAlertGroupForwardsCount++)

   794             {

   795             iAlertGroupWin.SetOrdinalPosition(0, KMaxTInt); 

   796             }

   797         }

   798     else if (--iAlertGroupForwardsCount == 0)

   799         {

   800         iAlertGroupWin.SetOrdinalPosition(0, ECoeWinPriorityNeverAtFront); 

   801         }

   802     }

   803 

   804 EXPORT_C void CEikServAppUiBase::SetStatusPaneFlags(TInt /*aFlags*/)

   805     {

   806     User::Leave(KErrNotSupported);

   807     }

   808 

   809 EXPORT_C void CEikServAppUiBase::SetStatusPaneLayoutL(TInt /*aLayoutResId*/)

   810     {

   811     User::Leave(KErrNotSupported);

   812     }

   813 

   814 EXPORT_C void CEikServAppUiBase::BlankScreenL()

   815     {

   816     User::Leave(KErrNotSupported);

   817     }

   818 

   819 EXPORT_C void CEikServAppUiBase::UnblankScreen()

   820     {

   821     User::Leave(KErrNotSupported);

   822     }

   823 

   824 EXPORT_C void CEikServAppUiBase::ShutdownAppsL(const TUid aRequesterUID, 

   825     const RMessage2& aShutdownMessage, const TInt aTimeoutInMicroseconds)

   826     {

   827     CEikSrvAppShutdown::StartL(aRequesterUID, aShutdownMessage, aTimeoutInMicroseconds);

   828     }

   829 

   830 EXPORT_C void CEikServAppUiBase::HandleResourceChangeL(TInt aType)

   831     {

   832     CAknAppUiBase::HandleResourceChangeL(aType);

   833     }

   834 

   835 void CEikServAppUiBase::Extension(TUid /*aExtensionUid*/, const TDesC8& /*aBuffer*/, 

   836     RMessagePtr2 /*aMessage*/)

   837     {

   838     // Not implemented

   839     }

   840 

   841 EXPORT_C void CEikServAppUiBase::HandleWsEventL(const TWsEvent& aEvent,CCoeControl* aDestination)

   842     {

   843     CAknAppUiBase::HandleWsEventL(aEvent, aDestination);

   844     }

   845 

   846 void CEikServAppUiBase::SetSgcParamsL(TInt /*aWgId*/, TBitFlags /*aAppFlags*/, TInt /*aSpLayout*/, 

   847     TInt /*aSpFlags*/)

   848     {

   849     }

   850 

   851 void CEikServAppUiBase::PrepareForAppExitL(TInt /*aWgId*/)

   852     {

   853     }

   854 

   855 

   856 // =============

   857 // CEikServAppUi

   858 // =============

   859 

   860 void CEikServAppUi::SetStatusPaneFlags(TInt aFlags)

   861     {

   862     if (iAknCapServerClient.Handle())

   863         {

   864         iAknCapServerClient.SetStatusPaneFlags(aFlags);

   865         }

   866     }

   867 

   868 void CEikServAppUi::SetStatusPaneLayoutL(TInt aLayoutResId)

   869     {

   870     if (iAknCapServerClient.Handle())

   871         {

   872         iAknCapServerClient.SetStatusPaneLayout(aLayoutResId);

   873         }

   874     }

   875 

   876 void CEikServAppUi::BlankScreenL()

   877     {

   878     if (iAknCapServerClient.Handle())

   879         {

   880         iAknCapServerClient.BlankScreen();

   881         }

   882     }

   883 

   884 void CEikServAppUi::UnblankScreen()

   885     {

   886     if (iAknCapServerClient.Handle())

   887         {

   888         iAknCapServerClient.UnblankScreen();

   889         }

   890     }

   891 

   892 void CEikServAppUi::EnableTaskListL()

   893     {

   894     User::LeaveIfError(iAknCapServerClient.EnableTaskList(ETrue));

   895     }

   896 

   897 void CEikServAppUi::LaunchTaskListL() //const

   898     {

   899     User::LeaveIfError(iAknCapServerClient.MakeTaskListVisible(ETrue));

   900     }

   901 

   902 void CEikServAppUi::CloseTaskList() //const

   903     {

   904     // Ignore possible error.

   905     iAknCapServerClient.MakeTaskListVisible(EFalse);

   906     }

   907 

   908 CEikServAppUi::CEikServAppUi()

   909     {

   910     }

   911 

   912 void CEikServAppUi::ConstructL()

   913     {

   914     // Create stub to allow device boot up with old notifier controller dependencies.

   915     iNotifierDialogController = CNotifierDialogController::NewL(0);

   916 

   917 #ifdef _DEBUG

   918     RDebug::Print(_L("CEikServAppUi::ConstructL() in"));

   919 #endif

   920 

   921     AknsUtils::InitSkinSupportL();

   922 #ifdef _DEBUG

   923     RDebug::Print(_L("CEikServAppUi::ConstructL() init skins ok"));

   924 #endif

   925 

   926     CEikServAppUiBase::ConstructL();

   927 #ifdef _DEBUG

   928     RDebug::Print(_L("CEikServAppUi::ConstructL() CEikServAppUiBase constructed"));

   929 #endif

   930 

   931     AknsUtils::SetAvkonSkinEnabledL( ETrue );

   932 #ifdef _DEBUG

   933     RDebug::Print(_L("CEikServAppUi::ConstructL(), CEikServAppUiBase::ConstructL() succeed"));

   934 #endif

   935 

   936     AknsUtils::SetAvkonSkinEnabledL( ETrue );

   937 #ifdef _DEBUG

   938     RDebug::Print(_L("CEikServAppUiBase::ConstructL(), Skins enabled"));

   939 #endif

   940 

   941     TFileName fileName(KResFileName);

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

   943     iResourceFileOffset = iCoeEnv->AddResourceFileL(fileName);

   944 

   945     // Create notifier controller before Notfier server is started.

   946     iNotifierController = CAknNotifierController::NewL();

   947 

   948 #ifdef _DEBUG

   949     RDebug::Print(_L("CEikServAppUi::ConstructL(), initializing Alert"));

   950 #endif

   951 

   952     CEikServNotifyAlert* alert=new(ELeave) CEikServNotifyAlert;

   953     CleanupStack::PushL(alert);

   954     alert->ConstructL();

   955     TEikServCtrlFactories fctry;

   956     fctry.iAlert = alert;

   957     fctry.iAlarmAlert = this;

   958     CleanupStack::Pop();

   959 

   960 #ifdef _DEBUG

   961     RDebug::Print(_L("CEikServAppUi::ConstructL(), Alert created"));

   962 #endif

   963 

   964     CEikServAppUiBase::InitializeL(fctry);

   965 

   966 #ifdef _DEBUG

   967     RDebug::Print(_L("CEikServAppUiBase::InitializeL(fctry) succeed"));

   968 #endif

   969 

   970     RWsSession& wsSession = iCoeEnv->WsSession();

   971 

   972     // Initialize some system settings.

   973     TRAP_IGNORE(EnsureExternalKeyHandlerAppStreamExistsL());

   974 

   975 #ifdef _DEBUG

   976     RDebug::Print(_L("CEikServAppUi::ConstructL(), Creating WG for status pane"));

   977 #endif

   978 

   979     // Create high priority windows for app bar and side bar.

   980     iOffScreenGroupWin = RWindowGroup(wsSession);

   981     User::LeaveIfError(iOffScreenGroupWin.Construct((TUint32)&iOffScreenGroupWin, 

   982         EFalse)); // EFalse disables key events

   983     iOffScreenGroupWin.SetOrdinalPosition(0,ECoeWinPriorityHigh);

   984 

   985 #ifdef _DEBUG

   986     RDebug::Print(_L("CEikServAppUi::ConstructL(), Starting sound server"));

   987 #endif

   988 

   989     // Launch the Avkon KeySound Server

   990     User::LeaveIfError(CEikKeySoundServer::LaunchServer(iKeySoundThreadId));

   991     

   992     // Start the Avkon Anim Dll - required for keysounds

   993     iAknAnimDll = new(ELeave)RAnimDll(wsSession);

   994     iAknAnimDll->Load(KAnimDllFileName);

   995     iAknAnimKeySound = new(ELeave)RAknAnimKeySound(*iAknAnimDll);

   996     iAknAnimKeySound->ConstructL(&iOffScreenGroupWin);

   997 

   998 #ifdef _DEBUG

   999     RDebug::Print(_L("CEikServAppUi::ConstructL(), Keysounds and plugin initialized"));

  1000 #endif

  1001 

  1002     // Create default keysounds - pass in UID.

  1003     ReplaceKeySoundsL(0x100053D0);

  1004 

  1005 #ifdef _DEBUG

  1006     RDebug::Print(_L("CEikServAppUi::ConstructL(), Default client and context for keysound created "));

  1007 #endif

  1008 

  1009     // Window server buffer size.

  1010     RWsSession &ws = iEikonEnv->WsSession();

  1011     TInt bufSize = 6400;

  1012     ws.SetMaxBufferSizeL(bufSize);

  1013 

  1014     // Load bitmap cursors.

  1015     LoadBitmapCursorsL();

  1016 

  1017     STATIC_CAST(CEikServEnv*,CEikonEnv::Static())->SetEikServAppUiSessionFactory( this );

  1018 

  1019 #ifdef _DEBUG

  1020     RDebug::Print(_L("CEikServAppUi::ConstructL(), over and out"));

  1021 #endif

  1022     }

  1023 

  1024 

  1025 void CEikServAppUi::RestartKeySoundThreadL()

  1026     {

  1027     // Restart keysound server.

  1028     TInt err = CEikKeySoundServer::LaunchServer(iKeySoundThreadId);

  1029     if (err != KErrNone)

  1030         {

  1031         // Server cannot be restarted, so leave existing animation dll.

  1032         // No sounds will be played, but machine will still operate.

  1033         return;

  1034         }

  1035         

  1036     // Restart the animation dll

  1037     if (iAknAnimKeySound)

  1038         {

  1039         iAknAnimKeySound->Close();

  1040         delete iAknAnimKeySound;

  1041         iAknAnimKeySound = NULL;

  1042         }

  1043         

  1044     if (iAknAnimDll)

  1045         {

  1046         iAknAnimDll->Close();

  1047         delete iAknAnimDll;

  1048         iAknAnimDll = NULL;

  1049         }

  1050 

  1051     // Restart the animation dll.

  1052     iAknAnimDll = new(ELeave)RAnimDll(iCoeEnv->WsSession());

  1053     iAknAnimDll->Load(KAnimDllFileName);

  1054     iAknAnimKeySound = new(ELeave)RAknAnimKeySound(*iAknAnimDll);

  1055     iAknAnimKeySound->ConstructL(&iOffScreenGroupWin);

  1056 

  1057     // Invented new API.

  1058     ReplaceKeySoundsL(0x100053D0);

  1059     KeySounds()->BringToForeground();

  1060     }

  1061 

  1062 

  1063 void CEikServAppUi::HandleThreadExitL(RThread& aThread)

  1064     {

  1065     if(aThread.Name().CompareF(_L("aknnfysrv")) == 0)

  1066         {

  1067         StartNewServerApplicationL(KCommonNotifierAppSrvUid);

  1068         return;

  1069         }

  1070 

  1071     TThreadId id = aThread.Id();

  1072     TExitType exitType = aThread.ExitType();

  1073     if (id == iExternalKeyHandlerThreadId)

  1074         {

  1075         iExternalKeyHandlerRunning = EFalse;

  1076         }

  1077     else if (id == iHelpAppThreadId)

  1078         {

  1079         iHelpAppRunning = EFalse;

  1080         }

  1081     else if (id == iKeySoundThreadId)

  1082         {

  1083         RestartKeySoundThreadL();

  1084         // Don't tell the user about it.

  1085         return;

  1086         }

  1087 

  1088     TBool rdSupport = BaflUtils::FileExists( iEikonEnv->FsSession(), KRDSupport );

  1089 

  1090     // Show panic notes only if that feature is enabled.

  1091     if ( exitType == EExitPanic && ( rdSupport || FeatureManager::FeatureSupported( 

  1092         KFeatureIdShowPanics )) )

  1093         {

  1094         // Construct text for a panic note.

  1095         HBufC* panicText = ConstructPanicTextLC( aThread, rdSupport );

  1096         

  1097         iAknCapServerClient.ShowGlobalNoteL(panicText->Des(), EAknGlobalErrorNote);

  1098         CleanupStack::PopAndDestroy(); // panicText

  1099         }

  1100         

  1101     CEikServAppUiBase::HandleThreadExitL(aThread);

  1102     }

  1103 

  1104 void CEikServAppUi::UpdateTaskListL()

  1105     {

  1106     iAknCapServerClient.UpdateTaskList();

  1107     }

  1108 

  1109 TKeyResponse CEikServAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode /*aType*/)

  1110     {

  1111     if (aKeyEvent.iCode == CTRL('e')) // Exit

  1112         {

  1113         CBaActiveScheduler::Exit();

  1114         }

  1115     return EKeyWasConsumed;

  1116     }

  1117 

  1118 void CEikServAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)

  1119     {

  1120     switch (aEvent.Type())

  1121         {

  1122         case EEventPassword:

  1123             {

  1124             // No action in Avkon.

  1125             break;

  1126             }

  1127         case EEventErrorMessage:

  1128             HandleErrorMessageEvent(*(aEvent.ErrorMessage()));

  1129             break;

  1130         case KUidValueAknsSkinChangeEvent:

  1131             {

  1132             HandleResourceChangeL(KAknsMessageSkinChange);

  1133             HandleStackedControlsResourceChange(KAknsMessageSkinChange);

  1134             break;