1 /*

     2 * Copyright (c) 2005-2009 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:  Controller for the PhoneUI View component

    15 *

    16 */

    17 

    18 #ifndef CPHONEVIEWCONTROLLER_H

    19 #define CPHONEVIEWCONTROLLER_H

    20 

    21 //  INCLUDES

    22 #include <apgcli.h>

    23 #include <eikenv.h>

    24 #include <e32base.h>

    25 #include <cntdef.h>

    26 #include <cphcntspeeddialmonitor.h>

    27 #include <AknsSrvClient.h>

    28 

    29 #include "mphoneviewcommandhandle.h"

    30 #include "cphonerecoverysystem.h"

    31 #include "mphonestatuspaneobserver.h"

    32 #include "tphonecmdparamspeeddial.h"

    33 #include "aknkeylock.h"

    34 #include "tphonecmdparamtranseffect.h"

    35 

    36 #include "mphoneviewblockingdialogobserver.h"

    37 #include "mnumberentry.h"

    38 #include "mphonesecuritymodechangeobserver.h"

    39 

    40 #include "mphoneviewcontrollerobserver.h"

    41 

    42 // FORWARD DECLARATIONS

    43 class CPhoneButtonsController;

    44 class CLogsClient;

    45 class CPhoneView;

    46 class CPhoneDialerView;

    47 class TPhoneViewId;

    48 class TPhoneCommandParam;

    49 class CEikButtonGroupContainer;

    50 class CPhoneMenuController;

    51 class CPhoneNoteController;

    52 class CPhoneQueryController;

    53 class CPhoneKeyCaptureController;

    54 class CSpdiaControl;

    55 class CEikStatusPane;

    56 class CAknNavigationControlContainer;

    57 class CPhoneBubbleWrapper;

    58 class CCoeControl;

    59 class CPhoneStatusPane;

    60 class TPhoneNoteType;

    61 class CPhoneNoteUtilities;

    62 class CPhoneIncallIndicator;

    63 class CPhoneTimer;

    64 class CPhoneContactController;

    65 class CPhoneCntSaveAddToName;

    66 class CPhCntSingleItemFetch;

    67 class CPhoneApplicationExit;

    68 class CPhoneAudioController;

    69 class CPhoneRingingTonePlayerAO;

    70 class RAknUiServer;

    71 class CPhoneSingleItemFetch;

    72 class CPhoneDialerController;

    73 class CAknIndicatorContainer;

    74 class CPhCntRfsHandler;

    75 class CPhoneToolbarController;

    76 

    77 class CEikonEnv;

    78 class CPhoneVmbxHandler;

    79 class CAknAppUi;

    80 class CDialer;

    81 class MPhoneNumberEntryChangedHandler;

    82 class MPhoneViewCustomization;

    83 class CPhoneEasyDialingController;

    84 class CPhoneDtmfDialerController;

    85 class CAknIncallBubble;

    86 

    87 class CPhoneViewController :

    88     public CBase,

    89     public MPhoneViewCommandHandle,

    90     public MPhoneStatusPaneObserver,

    91     public MPhoneViewBlockingDialogObserver,

    92     public MNumberEntryObserver,

    93     public MPhoneSecurityModeChangeObserver,

    94     public MPhoneViewControllerObserver,

    95     public MAknsSkinChangeObserver

    96     {

    97     public:  // Constructors and destructor

    98 

    99         IMPORT_C static CPhoneViewController* NewL( TRect aRect );

   100 

   101         /**

   102         * Destructor.

   103         */

   104         IMPORT_C virtual ~CPhoneViewController();

   105 

   106         IMPORT_C CPhoneView* PhoneView();

   107 

   108         /**

   109         * From MPhoneViewCommandHandle

   110         */

   111         IMPORT_C virtual void ExecuteCommandL(

   112             TPhoneViewCommandId aCmdId );

   113 

   114         /**

   115         * From MPhoneViewCommandHandle

   116         */

   117         IMPORT_C virtual void ExecuteCommandL(

   118             TPhoneViewCommandId aCmdId,

   119             TInt aCallId );

   120 

   121         /**

   122         * From MPhoneViewCommandHandle

   123         */

   124         IMPORT_C virtual void ExecuteCommandL(

   125             TPhoneViewCommandId aCmdId,

   126             TPhoneCommandParam* aCommandParam );

   127 

   128         /**

   129         * From MPhoneViewCommandHandle

   130         */

   131         IMPORT_C virtual void ExecuteCommandL(

   132             TPhoneViewCommandId aCmdId,

   133             TInt aCallId,

   134             TPhoneCommandParam* aCommandParam );

   135 

   136         /**

   137         * From MPhoneViewCommandHandle

   138         */

   139         IMPORT_C virtual void ExecuteCommandL(

   140             TPhoneViewCommandId aCmdId,

   141             TInt aCallId,

   142             TDesC& aMessage );

   143 

   144         /**

   145         * From MPhoneViewCommandHandle

   146         */

   147         IMPORT_C virtual void ExecuteCommand(

   148             TPhoneViewCommandId aCmdId );

   149 

   150         /**

   151         * From MPhoneViewCommandHandle

   152         */

   153         IMPORT_C virtual void ExecuteCommand(

   154             TPhoneViewCommandId aCmdId,

   155             TPhoneCommandParam* aCommandParam );

   156 

   157         /**

   158         * From MPhoneViewCommandHandle

   159         */

   160         IMPORT_C virtual TPhoneViewResponseId HandleCommandL(

   161             TPhoneViewCommandId aCmdId );

   162 

   163         /**

   164         * From MPhoneViewCommandHandle

   165         */

   166         IMPORT_C virtual TPhoneViewResponseId HandleCommandL(

   167             TPhoneViewCommandId aCmdId,

   168             TPhoneCommandParam* aCommandParam );

   169 

   170         /**

   171         * From MPhoneViewCommandHandle

   172         */

   173         IMPORT_C virtual const TDesC& FetchContent();

   174 

   175         /**

   176         * @see MPhoneStatusPaneObserver.

   177         */

   178         void HandleTitlePaneActiveL( TBool aActive = ETrue );

   179 

   180         /**

   181         * Returns window group id of the phone application.

   182         */

   183         IMPORT_C TInt ApplicationWindowGroupId();

   184 

   185         /**

   186         * Returns window group id of the Idle application.

   187         */

   188         IMPORT_C TInt IdleWindowGroupId();

   189 

   190         /**

   191         * Returns window group id of the application that is currently

   192         * in the foreground.

   193         */

   194         IMPORT_C TInt ForegroundApplicationWindowGroupId();

   195 

   196         /**

   197         * Fetches foreground application's window group id.

   198         */

   199         IMPORT_C static TInt DoFetchForegroundApplicationWindowGroupIdL(

   200             CEikonEnv& aEnv );

   201 

   202         /**

   203         * Hides / makes visible Phone icon in fast swap menu.

   204         * @since 2.8

   205         * @param aHidden is application hidden or shown.

   206         */

   207         IMPORT_C void SetHiddenL( const TBool aHidden );

   208 

   209         /**

   210         * Get the help context

   211         * @return Saved help context

   212         */

   213         IMPORT_C const TDesC& HelpContext();

   214 

   215         /**

   216         * From CCoeControl; notifier for resource changes

   217         * @param aType : Type of resource change

   218         */

   219         IMPORT_C void HandleResourceChangeL( TInt aType );

   220 

   221         /**

   222         * From CCoeControl; notifier for layout changes

   223         * @param aRect : screen size

   224         */

   225         IMPORT_C void HandleLayoutChange( TRect aRect );

   226 

   227         /**

   228         * Indicates that a blocking dialog is currently being displayed

   229         * This is required by the AppUI to determine if

   230         * the End key should be processed in HandleWsEventL()

   231         */

   232         IMPORT_C TBool BlockingDialogIsDisplayed() const;

   233 

   234         /**

   235         * Indicates that a status panel is currently being displayed

   236         * This is required by the AppUI

   237         */

   238         IMPORT_C TBool StatusPaneDisplayed();

   239 

   240         /**

   241         * Set single item fetch content

   242         */

   243         void SetFetchContent( TDesC& aFetchContent );

   244 

   245         /**

   246         * Sets single item fetch type

   247         * @aType   single item fetch type

   248         */

   249         void SetSingleItemFetchType( TInt aType );

   250 

   251          /**

   252         * From MPhoneViewBlockingDialogObserver

   253         * Sets the is blocking dialogs in screen.

   254         * @param aBlockingDialog ETrue if blocking dialog is

   255         *                        displayed.

   256         */

   257         IMPORT_C void SetBlockingDialogIsDisplayed( TBool aBlockingDialog );

   258 

   259         /**

   260          * From base class MNumberEntryObserver

   261          * Indication that numberentry state changed

   262          */

   263         void NumberEntryStateChanged( TBool aEntryHasText );

   264 

   265 // From MPhoneSecurityModeChangeObserver

   266 

   267         IMPORT_C void HandleSecurityModeChanged( TBool aIsEnabled );

   268 

   269         /**

   270         * Sets incall small bubble´s visibility in special cases.

   271         */

   272         void AllowInCallBubbleInSpecialCases();

   273 

   274         /**

   275         * Sets value for incall bubble visibility.

   276         */

   277         void SetIncallBubbleVisibility( TBool aIncallBubbleVisible );

   278 

   279     private:     // New functions

   280 

   281         /**

   282          * Set security mode

   283          *

   284          * @param aMode ETrue if mode should be set enabled.

   285          */

   286         void SetSecurityMode( TBool aMode );

   287 

   288         /**

   289         * read IdleApplicationUid from PubSub

   290         */

   291         TInt IdleAppUid();

   292 

   293         /**

   294         * Indicates whether application needs to return to the

   295         * background after being brought to the foreground using

   296         * BringToForeground()

   297         */

   298         TBool GetNeedToReturnToForegroundAppAfterCallL();

   299 

   300         /**

   301         * Gets the blocking dialogs status

   302         */

   303         void GetBlockingDialogIsDisplayed( TPhoneCommandParam* aCommandParam );

   304 

   305         /**

   306         * Sets the required background status of the application

   307         */

   308         void SetNeedToReturnToForegroundAppAfterCall( TPhoneCommandParam* aCommandParam );

   309 

   310         /**

   311         * Sends application to background.

   312         */

   313         void SendToBackgroundL();

   314 

   315         /**

   316         * Brings foreground given application.

   317         * @param aCommandParam command parameter.

   318         */

   319         void BringAppToForeground( TPhoneCommandParam* aCommandParam );

   320 

   321         /**

   322         * Brings phone application to foreground.

   323         * @param aCommandParam command parameter.

   324         */

   325         void BringPhoneAppToForeground( TPhoneCommandParam* aCommandParam );

   326 

   327         /**

   328         * Sets the top application

   329         * @param aCommandParam command parameter

   330         */

   331         void SetTopApplicationL( TPhoneCommandParam* aCommandParam );

   332 

   333         /**

   334         * Gets the foreground application

   335         * @param aCommandParam command parameter

   336         */

   337         void GetForegroundApplication( TPhoneCommandParam* aCommandParam );

   338 

   339         /**

   340         * Sets phone application windowgroup position.

   341         */

   342         void SetWindowGroupPosition();

   343 

   344         /**

   345         * Activate other application.

   346         * @param aCommandParam command parameter

   347         */

   348         void ActivateAppL( TPhoneCommandParam* aCommandParam );

   349 

   350         /**

   351         * Activate other application with specific view.

   352         * @param aCommandParam command parameter

   353         */

   354         void ActivateAppViewL( TPhoneCommandParam* aCommandParam );

   355 

   356         /**

   357         * Activate other application with specific view and custom message.

   358         * @param aCommandParam command parameter

   359         */

   360         void ActivateAppViewWithCustomMessageL(

   361             TPhoneCommandParam* aCommandParam );

   362 

   363         /**

   364         * Activate other application with specific view with conventional way

   365         * @param aCommandParam command parameter

   366         */

   367         void ActivateAppViewConventionalL( TPhoneCommandParam* aCommandParam );

   368 

   369         /**

   370         * Launches multimedia sharing (live video sharing)

   371         */

   372         static void LaunchMultimediaSharingL();

   373 

   374         /**

   375         * Launches application.

   376         */

   377         void LaunchApplicationL();

   378 

   379         /**

   380         * Launches help application

   381         * @param aHelpCommand help command string

   382         */

   383         void LaunchHelpApplicationL( const TDesC& aHelpCommand );

   384 

   385         /**

   386         * Continues construction of contact manager.

   387         */

   388         static TInt DoConstructContactControllerL( TAny* aAny );

   389 

   390         void SetCbaL( TPhoneCommandParam* aCommandParam );

   391 

   392         void ShowInfoNote( TPhoneCommandParam* aCommandParam );

   393 

   394         /**

   395         * Creates connection.

   396         */

   397         void CreateConnectionL();

   398 

   399         /**

   400         * Activate another instance of the application

   401         */

   402         void ActivateAppInstanceL( TUid aUid );

   403 

   404         /**

   405         * Set the global Avkon notifier disabler status

   406         * @param aCommandParam a command parameter

   407         */

   408         void SetGlobalNotifiersDisabledL( TPhoneCommandParam* aCommandParam );

   409 

   410         /* Set the Eikon notifier disable status

   411         * @param aCommandParam a command parameter

   412         */

   413         void SetEikonNotifiersDisabled( TPhoneCommandParam* aCommandParam );

   414 

   415         /**

   416         * Cancel all notification from screen.

   417         */

   418         void CancelAllNotications();

   419 

   420         /**

   421         * Handles bubble updating

   422         */

   423         void HandleUpdateBubbleL(

   424             TInt aCallId,

   425             TPhoneCommandParam* aCommandParam );

   426 

   427         /**

   428         * Remove Phone dialogs

   429         */

   430         void RemovePhoneDialogsL();

   431 

   432         /**

   433         * Remove add to contact dialog.

   434         */

   435         void RemoveAddToContactDialog();

   436 

   437         /**

   438         * Update menu and CBAs based on current audio path

   439         * @param aCommandParam a command parameter

   440         */

   441         void UpdateAudioPathOptions( TPhoneCommandParam* aCommandParam );

   442 

   443         /**

   444         * Update menu and CBAs based on current audio availability

   445         * @param aCommandParam a command parameter

   446         */

   447         void UpdateAudioAvailabilityOptions( TPhoneCommandParam* aCommandParam );

   448 

   449         /**

   450         /**

   451         * Soft Reject feature enable status

   452         */

   453         TBool SoftRejectIsEnabled() const;

   454 

   455         /**

   456         * Set Speed Dial location

   457         */

   458         void SetSpeedDialLocation( TPhoneCommandParam* aCommandParam );

   459 

   460         /**

   461         * Get number from Speed Dial location

   462         * @return   EFalse if user cancel or failed.

   463         */

   464         TBool GetNumberFromSpeedDialLocationL(

   465             TPhoneCommandParam* aCommandParam );

   466 

   467         /**

   468         * Assign Speed Dial location

   469         * @param aCommandParam a command parameter

   470         * @return ETrue if speed dial location is assigned

   471         */

   472         TBool AssignSpeedDialLocation( TPhoneCommandParam* aCommandParam );

   473 

   474         /**

   475         * Assign Speed Dial location

   476         * @param aLocation a speed dial location

   477         * @return ETrue if speed dial location is assigned

   478         */

   479         TBool AssignSpeedDialLocationL( TInt aLocation );

   480 

   481         /**

   482         * Opens Contact and adds address to contacts.

   483         * @param aCommand a contact command

   484         * @param aString a string to be added to contacts, if KNullDesC string

   485         *                will be added from the number entry.

   486         */

   487         void OpenAddToContactL( TInt aCommand,

   488                                 const TDesC& aString = KNullDesC );

   489 

   490         /**

   491         * Launches Restore Factory Settings

   492         * @param aDeepRfs - ETrue if deep rfs, EFalse if normal

   493         */

   494         void LaunchRfsL( TBool aDeepRfs );

   495 

   496         /**

   497         * Open the SMS or MMS message editor

   498         */

   499         void OpenMessageEditorL( TPhoneCommandParam* aCommandParam );

   500 

   501         /**

   502         * Open the soft reject message editor

   503         */

   504         void OpenSoftRejectMessageEditorL(TPhoneCommandParam* aCommandParam );

   505 

   506         /**

   507         * By default EPOC constructor is private.

   508         */

   509         void ConstructL( TRect aRect );

   510 

   511         /**

   512         * C++ default constructor.

   513         */

   514         CPhoneViewController();

   515 

   516         /**

   517         * Fetches phone number's type for aSpeedDialLocation located number.

   518         * @param aSpeedDialLocation - speed dial location of number.

   519         * @return Phone number's type.

   520         */

   521         TPhoneNumberType SpeedDialNumberTypeL( TInt aSpeedDialLocation );

   522 

   523         /**

   524         * Convert number type from Speed Dial field info

   525         * @param  aFieldInfo - field info

   526         * @return Phone number's type

   527         */

   528         TPhoneNumberType ConvertNumberTypeFromSpeedDialFieldInfo(

   529             const CPhCntSpeedDialMonitor::TSpdDialFieldInfo& aFieldInfo  );

   530 

   531         /**

   532         * Open the Unified message editor and get

   533         * number from number entry

   534         */

   535         void SendMessageL();

   536 

   537         /**

   538         * Set security mode to view and statuspane

   539         */

   540         void SetStatusPaneVisible( TPhoneCommandParam* aCommandParam );

   541 

   542         /**

   543         * Reads information is security code query displayed on the screen.

   544         * @return ETrue if is displayed, otherwise EFalse

   545         */

   546         TBool IsSecurityCodeQuery() const;

   547 

   548         /**

   549         * Set update of FSW

   550         */

   551         void UpdateFSW();

   552 

   553         /**

   554 

   555         /**

   556         * Creates Speed Dial Controller if it doesn't exist already.

   557         */

   558         void CreateSpeedDialControllerL();

   559 

   560         /**

   561         * Checks replace option.

   562         * @return ETrue if active and waiting calls are both video or voice

   563         */

   564         TBool IsReplaceAllowed();

   565 

   566         /**

   567         * Open single item fecth dialod for Dialer.

   568         */

   569         void SingleItemFetchL();

   570 

   571         /**

   572         * Get Soft Reject Window Group Id.

   573         */

   574         void GetSoftRejectWindowGroupId( TPhoneCommandParam* aCommandParam );

   575 

   576         /**

   577         * Switch flat status pane.

   578         */

   579         void SwitchLayoutToFlatStatusPaneL( TBool aSwitch );

   580 

   581         /**

   582         * Swap empty indicator pane.

   583         */

   584         void SwapEmptyIndicatorPaneL( const TBool aSwapEmpty );

   585 

   586         /**

   587         * Handles transition effect.

   588         */

   589         void HandleTransitionEffect( TPhoneTransEffectType aType,

   590                 const TUid& aAppUidEffectParam = KUidPhoneApplication );

   591 

   592         /**

   593         * Sets control to dialer.

   594         */

   595         void SetControltoDialerL();

   596 

   597         /**

   598         * Sets control to call handling.

   599         */

   600         void SetControltoCallHandlingL();

   601 

   602         /**

   603         * Sets control to dialer and makes control

   604         * visible if needed.

   605         */

   606         void SetDialerControlAndVisibilityL();

   607 

   608         /**

   609         * Sets pointer capture.

   610         * This is needed when statuspane must be inactive.

   611         */

   612         void CapturePointerEvents( TPhoneCommandParam* aCommandParam );

   613 

   614         /**

   615         * Returns allow waiting call header value.

   616         */

   617         void AllowWaitingCallHeaderL( TPhoneCommandParam* aCommandParam );

   618 

   619         /**

   620         * Checks if given window group id still exists in

   621         * window group list.

   622         *

   623         * @aAppWgID     window group id to check

   624         * @return TInt  KErrNotFound if app not exists anymore in the list

   625         *                   otherwise app index in the list.

   626         */

   627         TInt FindAppByWgIDL( TInt aAppWgID ) const;

   628 

   629        /**

   630         * Returns single item fetch type

   631         * @return single item fetch type

   632         */

   633         TInt SingleItemFetchType() const;

   634 

   635         /**

   636          * Checks if DTMF dialer mode is currently active

   637          */

   638         TBool IsDtmfDialerActive() const;

   639 

   640         /**

   641          * Checks if custom dialer mode is currently active

   642          */

   643         TBool IsCustomDialerActive() const;

   644 

   645         /**

   646         * Checks if the effect could and should be triggered.

   647         */

   648         TBool CanTransEffectBeUsed( TPhoneTransEffectType aType );

   649 

   650         /**

   651         * Triggers application start effect for the application

   652         * that is going to be lauched from dialer.

   653         * @param aAppUid app that is launched

   654         * EndTransEffect() must be called after app is launched.

   655         */

   656         void BeginTransEffectForAppStartFromDialerLC( const TUid& aAppUid );

   657 

   658         /**

   659         * Complete transition effect.

   660         */

   661         void EndTransEffect();

   662 

   663         /**

   664          * TCleanupOperation to call EndTransEffect, if leave occurs

   665          * after BeginTransEffectForAppStartFromDialerLC.

   666          */

   667         static void EffectCleanup(TAny* aThis );

   668 

   669         /**

   670          * Checks if emergency call is ongoing.

   671          */

   672         TBool IsEmergencyCallOngoing();

   673         

   674         /**

   675         * Is it ok to aType effect inside phoneapp.

   676         */

   677         TBool IsOkToUseThisTypeOfEffectInsidePhoneApp( 

   678                 TPhoneTransEffectType aType );

   679 

   680     private:

   681         /**

   682          * Called by the skin server when skin content is changed and the

   683          * connected client wants to be informed.

   684          *

   685          * @see MAknsSkinChangeObserver

   686          */

   687          void SkinContentChanged();

   688 

   689          /**

   690          * Called by the skin server to indicate that the current skin

   691          * configuration has changed.

   692          *

   693          * @see MAknsSkinChangeObserver

   694          */

   695          void SkinConfigurationChanged(

   696              const TAknsSkinStatusConfigurationChangeReason aReason );

   697 

   698          /**

   699          * Called by the skin server to indicate that the available

   700          * skin packages have changed.

   701          *

   702          * @see MAknsSkinChangeObserver

   703          */

   704          void SkinPackageChanged(

   705              const TAknsSkinStatusPackageChangeReason aReason );

   706 

   707     private:    // Data

   708 

   709         CPhoneView* iPhoneView;

   710 

   711         CPhoneDialerView* iDialerView;

   712 

   713         // iCba

   714         CEikButtonGroupContainer* iCba;

   715 

   716         CPhoneStatusPane* iStatusPane;

   717 

   718         // For accessing bubble

   719         CPhoneBubbleWrapper* iBubbleWrapper;

   720 

   721         // Controls the touch buttons

   722         CPhoneButtonsController* iButtonsController;

   723 

   724         // Controls the touch buttons

   725         CPhoneDialerController* iDialerController;

   726 

   727         // Controls touch dialer in DTMF mode

   728         CPhoneDtmfDialerController* iDtmfDialerController;

   729 

   730         // Controls the toolbar

   731         CPhoneToolbarController* iToolbarController;

   732 

   733         // Handles easydialing commands. Owned.

   734         CPhoneEasyDialingController* iEasyDialingController;

   735 

   736         // For accessing incall indicator

   737         CPhoneIncallIndicator* iIncallIndicator;

   738 

   739         CPhoneMenuController* iMenuController;

   740 

   741         CPhoneNoteController* iNoteController;

   742 

   743         CPhoneQueryController* iQueryController;

   744 

   745         CPhoneKeyCaptureController* iKeyCaptureController;

   746 

   747         CPhoneApplicationExit* iApplicationExit;

   748 

   749         CPhoneAudioController* iAudioController;

   750 

   751         CPhoneRingingTonePlayerAO* iRingingTonePlayerAO;

   752 

   753         // EikEnv for CPhoneKeyCaptureController, CPhoneNoteController,

   754         // CPhoneMenuController and CPhoneQueryController

   755         CEikonEnv& iEikEnv;

   756 

   757         // Instance of keylock.

   758         RAknKeyLock iKeyLock;

   759 

   760         CPhoneContactController* iContactController;

   761 

   762         // Window group of Idle application.

   763         TInt iIdleWg;

   764 

   765         // Boolean flag. ETrue if the application needs to return

   766         // to the background

   767         TBool iNeedToSendToBackground;

   768 

   769         // Owned server session.

   770         RApaLsSession iApaLsSession;

   771 

   772         // Saved help context name retrieved indirectly from AppUI when

   773         // the help application is launched

   774         TPtrC iHelpCommand;

   775 

   776         // Recovery id for contact manager construction.

   777         TRecoveryId iContactControllerId;

   778 

   779         // Boolean flag. ETrue if a blocking dialog is currently being

   780         // displayed.

   781         TBool iBlockingDialogIsDisplayed;

   782 

   783         //Pointer to Akn UI server, not owned.

   784         RAknUiServer* iAknUiServerClient;

   785 

   786         //Uid of idle application

   787         TInt iIdleUid;

   788 

   789         // Voice mailbox handler

   790         CPhoneVmbxHandler* iVmbxHandler;

   791 

   792         // Reference to speed dialling monitor.

   793         CPhCntSpeedDialMonitor* iSpeedDialController;

   794 

   795 

   796         // Dialer - owned

   797         CDialer* iDialer;

   798 

   799         // Pointer to the CPhoneSingleItemFetch

   800         CPhoneSingleItemFetch* iSingleItemFetch;

   801 

   802         // Content of the SingleItemFetch

   803         TBuf<KPhoneNumberEntryBufferSize> iFetchContent;

   804 

   805         // Type of the SingleItemFetch

   806         TInt iSingleItemFetchType;

   807 

   808         // Pointer to CPhoneCntSaveAddToName.

   809         CPhoneCntSaveAddToName* iContactSaveAddToName;

   810 

   811         // Previous application Window group id.

   812         TInt iPrevForegroundAppWg;

   813 

   814         CAknAppUi* iAppui;

   815 

   816         // Pointer to view customization.

   817         MPhoneViewCustomization* iCustomization;

   818 

   819         // Status if there is transition effect ongoing

   820         TBool iEffectOngoing;

   821 

   822         // Send back flag indicates send back need if it is

   823         // EFalse phone was foregound and there is no need to send it

   824         // background. Otherwise ETrue.

   825         TBool iSendBack;

   826 

   827         // Dialer status flag.

   828         TBool iDialerActive;

   829 

   830         CCoeControl* iPreviousIndicatorControl;

   831 

   832         // Empty indicator pane - Owned.

   833         CAknIndicatorContainer* iIndiContainer;

   834 

   835         // Owned

   836         CPhCntRfsHandler* iRfsHandler;

   837 

   838         // Dialer send key flag.

   839         TBool iDialerSendKeyActivation;

   840 

   841         TInt iPrevious;

   842 

   843         TBool iPriotityChanged;

   844 

   845         /**

   846          * Internal flag to define if security mode is enabled.

   847          */

   848         TBool iSecurityMode;

   849 

   850         // Boolean flag. ETrue if the application needs to return

   851         // to the foreground after call ended

   852         TBool iNeedToReturnToForegroundAppAfterCall;

   853 

   854         CAknIncallBubble* iIncallBubble;

   855 

   856         // Server wich sends events about background image changes

   857         RAknsSrvSession iSkinServerSession;

   858     };

   859 

   860 #endif // CPHONEVIEWCONTROLLER_H