1 /*

     2 * Copyright (c) 2007-2010 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:  App UI class for cameraapp

    15 *

    16 */

    17 

    18 

    19 #ifndef CAMAPPUI_H

    20 #define CAMAPPUI_H

    21 

    22 // ===========================================================================

    23 //  INCLUDES

    24 #include "CamAppUiBase.h"

    25 #include "CamNewFileService.h"

    26 #include "CamSelfTimerObserver.h"  

    27 #include "CamVolumeKeyObserver.h"

    28 #include "mcamcameraobserver.h"

    29 #include "CamFileCheckAo.h"

    30 

    31 #include "MCamAddToAlbumObserver.h"

    32 

    33 class CFbsBitGc;

    34 class CAknNavigationDecorator;

    35 class CAknNavigationControlContainer;

    36 class CCamWaitDialog;

    37 class CCamTimerBase;

    38 class CCamNaviCounterControl;

    39 class CCamNaviCounterModel;

    40 class CCamNaviProgressBarControl;

    41 class CCamNaviProgressBarModel;

    42 class CCamSelfTimer;

    43 class MCamBurstModeObserver;

    44 class CDocumentHandler;

    45 class CTextResolver;

    46 class CCamSidePane;

    47 class CCamZoomPane;

    48 class MCamResourceLoader;

    49 class CCamTimer;

    50 class CIdle;

    51 class CAknStylusPopUpMenu; 

    52 

    53 class CGSPluginInterface;

    54 class CGSTabHelper;

    55 class CCamGSInterface;

    56 

    57 class CAknGlobalNote;

    58 

    59 //class CASpaAppLauncherActionData;

    60 //class CSFIUtilsAppInterface;    // InCall Send interface

    61 class CCamPropertyWatcher;

    62 class CRepository;

    63 class MActivePalette2UI;

    64 class CCamActivePaletteHandler;

    65 class CAknLocalScreenClearer;

    66 class CAknStaticNoteDialog;

    67 class CCamCollectionManagerAO;

    68 class CCamStillPreCaptureView;

    69 class CCamVideoPreCaptureView;

    70 class CCamMemoryMonitor;

    71 //FTU message display class

    72 class CCamFtuDisplay;

    73 class CCamStartupLogoController;

    74 

    75 

    76 // ===========================================================================

    77 // CLASS DECLARATION

    78 

    79 /**

    80 *  AppUi class for Camera

    81 *

    82 *  @since 2.8

    83 */

    84 class CCamAppUi : public CCamAppUiBase,

    85                   public MCamSelfTimerObserver,

    86                   public MCamControllerObserver,

    87                   public MCamVolumeKeyObserver,

    88                   public MCamFileCheckObserver,

    89                   public MCamCameraObserver

    90                   ,public MCamAddToAlbumObserver

    91                   ,public MAknServerAppExitObserver

    92   {

    93   // =======================================================

    94   // Data Types

    95   private: 

    96         

    97     // enumeration to describe the type of view switch required when 

    98     // the capture mode or view state changes

    99     enum TCamViewSwitch

   100         {

   101         ECamViewSwitchNone,    // no switch required

   102         ECamViewSwitchModeOnly,// only capture mode or view state need updating

   103         ECamViewSwitch         // full view switch required including state 

   104                                // and mode update

   105         };

   106 

   107     /**

   108      * Enumeration used for the state of delayed postacapture views

   109      * construction. Only used if CAMERAAPP_DELAYED_POSTCAPTURE_CREATION is

   110      * enabled.

   111      */

   112     enum TCamPostCapConstruction

   113         {    

   114         ECamConstructStillPostCap,

   115         ECamConstructBurstPostCap,

   116         ECamConstructVideoPostCap,

   117         ECamPostCapsDone

   118         };

   119     

   120     enum TSoftkeyIndex

   121         {

   122         ESoftkeyIndex1 = 0,

   123         ESoftkeyIndex2 = 2

   124         };

   125       

   126     enum TPendingViewSwitchType 

   127         {

   128         EPendingViewSwitchNone = 0,

   129         EPendingViewSwitchNormal,

   130         EPendingViewSwitchDeactivateFirst

   131         };

   132 

   133     /**

   134      * Memory card status

   135      */

   136     enum TCamMemoryStatus

   137         {

   138         ECamMemoryStatusOK,

   139         ECamMemoryStatusFull,

   140         ECamMemoryStatusInternalFull,

   141         ECamMemoryStatusCardNotInserted,

   142         ECamMemoryStatusCardReadOnly,

   143         ECamMemoryStatusCardLocked,

   144         ECamMemoryStatusMassStorageFull

   145         };

   146 

   147   // =======================================================

   148   // Methods 

   149 

   150   // -------------------------------------------------------

   151   // Constructors and destructor

   152   public:  

   153 

   154     /**

   155     * C++ constructor.

   156     * @since 2.8

   157     * @param aController Reference to CCamAppController

   158     * @return Pointer to CCamAppUi

   159     */

   160     CCamAppUi( CCamAppController& aController );

   161 

   162     /**

   163     * Perform the second phase construction of a CCamAppUi object.

   164     * @since 2.8

   165     */

   166     void ConstructL();

   167 

   168     /**

   169     * Destructor.

   170     */

   171     virtual ~CCamAppUi();

   172   

   173   // -------------------------------------------------------

   174   // From MCamCameraObserver

   175   public:

   176 

   177     /**

   178     * Handle camera event.

   179     *

   180     * @param aStatus    Status code describing the event status.

   181     * @param aEventId   Identifier for the event.

   182     * @param aEventData Event associated data. If such data is provided with

   183     *                   the event, it is mentioned in the documentation of

   184     *                   particular event id.

   185     *                   Ownership not transferred to observer.

   186     */

   187     void HandleCameraEventL(

   188         TInt aStatus, 

   189         TCamCameraEventId aEventId, 

   190         TAny* aEventData = NULL );   

   191 

   192   // -------------------------------------------------------

   193   // From MCamFileCheckObserver

   194   public:

   195 

   196     /**

   197     * Callback to notify that file checking operation has completed.

   198     * @param aStatus Number of files that were missing

   199     * @param aError  Error code

   200     */

   201     void FileCheckingCompleteL( TInt aStatus, TInt aError );   

   202 

   203     // -------------------------------------------------------

   204     // New functions

   205 public: 

   206     /*

   207      * HyperlinkCallback

   208      * static methode  to be called from TCallback

   209      */

   210 

   211     static TInt HyperlinkCallback( TAny* aAny );

   212     

   213     /**

   214      * CamFtuDisplayL

   215      * Check if camera is launching for first time ,

   216      * accordingly FTU Message will be displayed.

   217      */

   218     void CamFtuDisplayL();

   219   

   220      /**

   221 	  * OpenSettingView

   222 	  * Non static public method , to launch the settings view

   223 	  */

   224     void OpenSettingView();

   225 

   226     /**

   227      * Returns whether or the toolbar has been activated/visible

   228      * Will return ETrue when when the toolbar is active/visible

   229      * @since 3.2

   230      * @return ETrue if toolbar is active/visible, else returns EFalse

   231      */

   232     virtual TBool IsToolBarVisible() const;

   233 

   234         /**

   235         * Check if given view state indicates that "internal",

   236         * CCamViewBase inherited view is in question.

   237         */

   238         TBool IsInternalView( TCamViewState aViewState ) const;

   239 

   240         /**

   241         * Set status of standby mode.

   242         */

   243         void SetStandbyStatus( TInt aStatus );

   244 

   245         /**

   246         * Get status of standby mode.

   247         */

   248         TInt StandbyStatus() const;

   249 

   250         /**

   251          * returns ETrue if the stsnby status is recoverable

   252          */

   253         TBool IsRecoverableStatus();

   254         

   255         /**

   256          * Change the standby status

   257          */

   258         TBool ChangeStandbyStatusL( TInt aError );

   259         

   260         /**

   261         * returns Getter for iPreCaptureMode

   262         */

   263         TCamPreCaptureMode PreCaptureMode();

   264         

   265         /*

   266         * Check for file name deletion/renaming outside camera

   267         */

   268         void StartFileNameCheck();

   269              

   270         /**

   271         * Determines whether or not all construction has been completed

   272         * Used on view activation to determine if the view should

   273         * open in standby mode. This will happen if the app is waiting for

   274         * an orientation switch to complete or for the initial view to be set

   275         * when launched in embedded

   276         * @since 3.0

   277         * @return ETrue if all construction has completed, else EFalse

   278         */   

   279         TBool IsConstructionComplete() const;

   280 

   281         /**

   282         * Set title pane text from a resource.

   283         * @since 2.8

   284         * @param aResourceId resource to read from

   285         */

   286         void SetTitleL( TInt aResourceId );

   287 

   288         /**

   289         * Set title pane text from a descriptor.

   290         * @since 2.8

   291         * @param aText title pane text

   292         */

   293         void SetTitleL( const TDesC& aText );

   294 

   295         /**

   296         * In embedded mode set title to name of embedding application

   297         * @since 2.8

   298         */

   299         void SetTitleEmbeddedL();

   300 

   301         /**

   302         * Push navi pane indicators on to navi pane stack.

   303         * @since 2.8

   304         */

   305         void PushNaviPaneCounterL();

   306 

   307         /**

   308         * Push navi pane progress bar on to navi pane stack.

   309         * @since 2.8

   310         */

   311         void PushNaviPaneProgressBarL();

   312 

   313         /**

   314         * Push default navi pane on to navi pane stack.

   315         * @since 2.8

   316         */

   317         void PushDefaultNaviPaneL();

   318 

   319         /**

   320         * Call DisplayDeleteNoteL on the current view

   321         * @return whether the delete was performed

   322         * @since 2.8

   323         */

   324         TBool DisplayDeleteNoteL();

   325 

   326         /**

   327         * Enable or disable self-timer functionality

   328         * @since 2.8

   329         * @param aEnable The selftimer functionality to use

   330         */

   331         void SelfTimerEnableL( TCamSelfTimerFunctions aEnable );

   332 

   333         /**

   334         * Returns current self-timer state

   335         * @since 2.8

   336         * @return Returns whether or not Self Timer is currently enabled.

   337         */

   338         TBool SelfTimerEnabled() const;

   339 

   340         /**

   341         * Returns pointer to self-timer

   342         * @since 2.8

   343         * @return pointer to CCamSelfTimer object.

   344         */

   345         CCamSelfTimer* SelfTimer();

   346 

   347         /**

   348         * Registers an observer for changes in burst mode activation

   349         * @since 2.8

   350         * @param aBurstModeObserver the object observing burst mode changes

   351         */

   352         void AddBurstModeObserverL( MCamBurstModeObserver* aBurstModeObserver );

   353 

   354         /**

   355         * Removes an observer for changes in burst mode activation

   356         * @since 2.8

   357         * @param aBurstModeObserver the observer to remove

   358         */

   359         void RemoveBurstModeObserver( const MCamBurstModeObserver* aBurstModeObserver );

   360 

   361         /**

   362         * Returns whether or not burst capture mode is enabled.

   363         * Will return ETrue when burst mode is enabled for still capture

   364         * even if the application is currently in video capture mode

   365         * @since 2.8

   366         * @return ETrue if burst mode is enabled, else returns EFalse

   367         */

   368         TBool IsBurstEnabled() const;

   369 

   370         /*

   371         * Gets the handle to the controller, which is used inturn by the

   372         * plugin to call the interfaces for performing needed actions.

   373         */

   374         MCamAppController& AppController();

   375         

   376         /*

   377         * Gets the handle to the settings model, which is used inturn by the

   378         * plugin to call the interfaces for performing needed actions.

   379         */

   380         MCamStaticSettings& StaticSettingsModel();

   381         

   382         /**

   383         * Returns the currently enabled burst mode.

   384         * @since 3.0

   385         * @return the currently enable burst mode or ECamImageCaptureNone if 

   386         * burst is not enabled

   387         */

   388         TCamImageCaptureMode CurrentBurstMode() const;

   389 

   390         /**

   391         * Sets the current capture mode ( and target capture mode )

   392         * @since 2.8

   393         */

   394         void SetCaptureMode(

   395             TCamCameraMode aMode, 

   396             TCamImageCaptureMode aImageMode = ECamImageCaptureNone );

   397 

   398         /**

   399         * Changes the state of sequence capture

   400         * @since 3.0

   401         * @param aImageMode Single/Multi/Timelapse

   402         * @param aReprepare Whether or not the engine should be reprepared with sequence

   403         * settings (Do not reprepare if the engine is about to be deleted/released)

   404         * @param aUpdateUi  Whether or not to do Ui update related things. Those are not

   405         * needed/allowed if this method is called just to return sequence mode setting

   406         * to default value (single capture).

   407         */ 

   408         void SwitchStillCaptureModeL( TCamImageCaptureMode aImageMode, 

   409                                       TBool                aReprepare, 

   410                                       TBool                aUpdateUi = ETrue );

   411 

   412 

   413         /**

   414         * Returns whether or the secondary camera has been activated

   415         * Will return ETrue when when the second camera is active

   416         * @since 2.8

   417         * @return ETrue if second camera is active, else returns EFalse

   418         */

   419         TBool IsSecondCameraEnabled() const;

   420 

   421         /**

   422         * Secondary camera orientation is constructed according to this flag.

   423         * Flag can be forced to portrait/landscape or it can follow qwerty 

   424         * state. Variation is handled via KCamCr2ndCamOrientation CenRep key.

   425         * @param aLock, Lock orientation state flag. 

   426         *               ETrue, ask state and lock it.

   427         *               EFalse, ask current state.

   428         * @return ETrue if secondary camera orientation must be landscape

   429         */

   430         TBool IsQwerty2ndCamera( TBool aLock = EFalse );  

   431 

   432         /**

   433         * 

   434         * @return ETrue if wait dialog exist

   435         */

   436         TBool CCamAppUi::IsWaitDialog() const;

   437 

   438         /**

   439         * Returns the active camera

   440         * @since 2.8

   441         * @return either primary, secondary or none ( if in process of switching )

   442         */

   443         TCamActiveCamera ActiveCamera() const;

   444 

   445         /**

   446         * Called just prior to capture. Checks if there is sufficient memory

   447         * available for capture and handles out of memory/error conditions. 

   448         * @since 2.8

   449         * @return ETrue if there is memory available for capture

   450         */

   451         TBool CheckMemoryL();

   452 

   453         /**

   454         * Display error note - with OK softkey only

   455         * @since 2.8

   456         * @param aStatus error status

   457         */

   458         void ShowErrorNoteL( TCamMemoryStatus aStatus );

   459 

   460         /**

   461         * Display error note for OOM condition - OK and Cancel softkeys

   462         * @since 2.8

   463         * @param aLabel text to be shown

   464         * @param aWithCancel Enables cancel softkey; default=ETrue

   465         * @return Response code returned from Out of memory dialog

   466         */

   467         TInt ShowOOMNoteL( TDesC& aLabel, TBool aWithCancel = ETrue);

   468 

   469         /**

   470         * Set the requested resolution for a new file

   471         * @since 3.2

   472         * @param aRequestedResolution the requested resolution from the new file request.

   473         */

   474         void SetRequestedNewFileResolution( const TSize& aRequestedResolution );

   475 

   476         /**

   477         * Get the requested resolution for a new file

   478         * @since 3.2

   479         * @return the requested resolution from the new file request.

   480         *  Default is TSize(0,0) which interpreted as mms quality resolution

   481         */

   482         TSize RequestedNewFileResolution() const;

   483 

   484         /**

   485         * Shows the mmc removal note if it is required

   486         * @since 2.8

   487         */

   488         void ShowMMCRemovalNoteIfRequiredL();

   489 

   490         /**

   491         * Check memory card for available space and card status

   492         * @since 2.8

   493         * @param aFull on return contains ETrue if card is full

   494         * @param aStatus on return contains the card status

   495         * @param aCurrentLocation current storage location

   496         */

   497         void CheckMemoryCard( TBool& aFull,

   498                 TCamMemoryStatus& aStatus, TCamMediaStorage aCurrentLocation );

   499 

   500         /**

   501         * Checks if aStorage location is full

   502         * @since 2.8

   503         * @param aStorage target storage location

   504         * @param aCurrentLocation current storage location

   505         * @return ETrue if aStorage location is full

   506         */

   507         TBool MemoryFull( TCamMediaStorage aStorage, TCamMediaStorage aCurrentLocation );

   508 

   509         /**

   510         * Starts the video/photo capture

   511         * @since 2.8

   512         * @param aKeyEvent Key used to start the capture

   513         * @return whether the key was consumed by the function

   514         */

   515         TKeyResponse StartCaptureL( const TKeyEvent& aKeyEvent );

   516 

   517         /**

   518         * Stops the video capture

   519         * @since 2.8

   520         */

   521         void EndCapture();

   522         

   523         /**

   524         * Changes the orientation to aNewOrientation

   525         * If aNewOrientation is EAppUiOrientationUnspecified, switches

   526         * to the normal orientation (this may depend on the currently

   527         * activated camera)

   528         * @since 3.0

   529         */

   530         void SwitchOrientationIfRequiredL( TInt aNewOrientation );

   531 

   532         /**

   533         * Returns pointer to side-pane

   534         * @since 2.8

   535         * @return pointer to CCamSidePane object constructed by appUi

   536         */

   537         CCamSidePane* SidePane();

   538 

   539         /**

   540         * Returns pointer to zoom-pane

   541         * @since 2.8

   542         * @return pointer to CCamZoomPane object constructed by appUi

   543         */

   544         CCamZoomPane* ZoomPane();

   545 

   546         /**

   547         * Returns current camera orientation

   548         * @since 3.0

   549         * @return current camera orientation

   550         */

   551         TCamOrientation CamOrientation();

   552 

   553         /**

   554         * set current camera orientation as landscape

   555         */

   556         void SetCamOrientationToLandscape();

   557 	

   558         /**

   559         * Returns current viewstate

   560         * @since 3.0

   561         * @return current viewstate

   562         */

   563         TCamViewState CurrentViewState() const;

   564         

   565         /**

   566         * Returns target view state

   567         * @since 4.0

   568         * @return target view state

   569         */

   570         TCamViewState TargetViewState();

   571 

   572         /**

   573         * Returns the target mode of current mode switch

   574         * (Image/Video/Idle/Shutdown). The returned value

   575         * should equal to current state, if no switch is

   576         * in progress

   577         */        

   578         TCamCameraMode TargetMode() const;

   579 

   580         /**

   581         * Handles the shutter key press

   582         * @param aPressed ETrue if the shutter is pressed, EFalse if released

   583         * @since 2.8

   584         */

   585         void HandleShutterKeyL( TBool aPressed );    

   586         

   587         /**

   588         * Set embedding flag 

   589         * @param aEmbedding ETrue if we are embedding (ie Messaging, Realplayer), 

   590         * EFalse if not

   591         * @since 2.8

   592         */

   593         void SetEmbedding( TBool aEmbedding );

   594         

   595         /**

   596         * Return embedding flag 

   597         * @return ETrue if we are embedding (ie Messaging, Realplayer), 

   598         * EFalse if not

   599         * @since 2.8

   600         */

   601         TBool Embedding() const;

   602         

   603         /**

   604         * Set SendAs flag 

   605         * @param aSendAsInProgress ETrue if SendAs in progress, EFalse if not

   606         * @since 2.8

   607         */

   608         void SetSendAsInProgressL( TBool aSendAsInProgress );

   609 

   610         /**

   611         * Get SendAs flag value 

   612         * @return ETrue if SendAs in progress, EFalse if not

   613         * @since 4.0

   614         */        

   615         virtual TBool SendAsInProgress() const;

   616         

   617         /**

   618         * Offers a pointer to appui's TextResolver instance

   619         * @return pointer to appui's TextResolver instance   

   620         */

   621         CTextResolver* TextResolver();

   622             

   623 #ifndef __WINSCW__

   624         /**

   625         * Get pointer to SFI utility class 

   626         * @since 3.0

   627         * @return pointer to CSFIUtilsAppInterface

   628         */

   629         //CSFIUtilsAppInterface* SFIUtility() const;

   630 

   631         /**

   632         * Return whether we are currently in-call send

   633         * @since 3.0

   634         * @return TBool true if we are in in-call send mode

   635         */

   636         //TBool IsInCallSend() const;

   637 

   638         /**

   639         * Send media file using SFI utility

   640         * @since 3.0

   641         */

   642         //void DoInCallSendL() const;

   643 #endif //WINSCW

   644 

   645         /**

   646         * Whether or not the application is in the background

   647         * @since 2.8

   648         * @param aIncludeNotifier If EFalse then the application is not

   649         * classed as being in the background if the foreground application is

   650         * a notifier, e.g. charging enabled.

   651         * @return ETrue if the application is in the background

   652         */   

   653         TBool AppInBackground( TBool aIncludeNotifier ) const;

   654         

   655         /**

   656         * Indicates whether or not the application is in a simulated exit situation

   657         * @return ETrue if the application has pretended to exit, else EFalse 

   658         */

   659         TBool IsInPretendExit() const;

   660         

   661         /**

   662         * Indicates whether or not the application was in a simulated exit situation

   663         * @return ETrue if the application had pretended to exit, else EFalse 

   664         */

   665         TBool ReturningFromPretendExit() const; 

   666         

   667         /**

   668         * Indicates whether or not the application started the first time

   669         * @return ETrue if the application booted first time, else EFalse 

   670         */

   671         TBool IsFirstBoot() const; 

   672                 

   673         /**

   674         * Returns whether an MMC removed note is pending

   675         * @since 3.0

   676         * @return TBool ETrue if the UI needs to show an MMC 

   677         */

   678         TBool IsMMCRemovedNotePending() const;                  

   679 

   680         /**

   681         * Returns the pointer to the NaviCounter pane

   682         * @since 3.0

   683         * @return The Navi Counter pointer

   684         */

   685         CCamNaviCounterControl* NaviCounterControl();

   686         

   687         /**

   688         * Returns the pointer to the NaviProgress pane

   689         * @since 3.0

   690         * @return The Navi Progress pointer

   691         */

   692         CCamNaviProgressBarControl* NaviProgressBarControl();

   693 

   694         /**

   695         * Returns the pointer to the Navi Counter ModelProgress pane

   696         * @since 3.0

   697         * @return The Navi Counter Model pointer

   698         */

   699         CCamNaviCounterModel* NaviCounterModel();

   700 

   701         /**

   702         * Return handle to active palette if supported

   703         * @since 3.0

   704         * @return Handle to Active palette

   705         */             

   706         MActivePalette2UI* ActivePalette() const;

   707         

   708         /**

   709         * Get pointer to Active Palette handler instance.

   710         *

   711         * @return Pointer to Active Palette handler instance. Ownership not

   712         *         transferred.

   713         */

   714         CCamActivePaletteHandler* APHandler() const;

   715 

   716         /**

   717         * Tries to show or hide the Active Toolbar

   718         * @since 3.0

   719         * @param aShown True to show it, False to hide it

   720         */

   721         void SetActivePaletteVisibility( TBool aShown );

   722 

   723         /**

   724         * Returns whether the user has set the icons to always display in pre-capture

   725         * @since 3.0

   726         * @return ETrue if the optional icons should always be displayed

   727         */

   728         TBool AlwaysDrawPreCaptureCourtesyUI() const;

   729 

   730         /**

   731         * Returns whether the user has set the icons to always display in post-capture

   732         * @since 3.0

   733         * @return ETrue if the optional icons should always be displayed

   734         */

   735         TBool AlwaysDrawPostCaptureCourtesyUI() const;

   736 

   737         /**

   738         * Set whether the icons should always display in pre-capture

   739         * @since 3.0

   740         * @param aNewSetting True if they should always be drawn; False if they should only be drawn when the UI is raised

   741         */

   742         void  SetAlwaysDrawPreCaptureCourtesyUI( TBool aNewSetting );

   743 

   744         /**

   745         * Set whether the icons should always display in post-capture

   746         * @since 3.0

   747         * @param aNewSetting True if they should always be drawn; False if they should only be drawn when the UI is raised

   748         */

   749         void SetAlwaysDrawPostCaptureCourtesyUI( TBool aNewSetting );

   750 

   751         /**

   752         * Check whether a key event should cause the courtesy UI to be raised

   753         * @since 3.0

   754         * @param aKeyEvent The key event

   755         * @param aType The type of key event

   756         * @param aInPreCapture Whether the key was pressed in precapture mode

   757         * @return Whether the key was consumed or not

   758         */

   759         TKeyResponse CheckCourtesyKeyEventL( const TKeyEvent aKeyEvent, TEventCode aType, TBool aInPreCapture );

   760 

   761         /**

   762         * Whether to draw the complete UI in precapture mode

   763         * @since 3.0

   764         * @return True if it should all be drawn

   765         */

   766         TBool DrawPreCaptureCourtesyUI() const;

   767 

   768         /**

   769         * Whether to draw the complete UI in postcapture mode

   770         * @since 3.0

   771         * @return True if it should all be drawn

   772         */

   773         TBool DrawPostCaptureCourtesyUI() const;

   774 

   775         /**

   776         * Bring the complete UI to the fore in precapture

   777         * @param aShowZoomBar Briefly shows the zoombar first, if necessary

   778         * @since 3.0

   779         */

   780         void RaisePreCaptureCourtesyUI(TBool aShowZoomBar);

   781 

   782         /**

   783         * Bring the complete UI to the fore in postcapture

   784         * @since 3.0

   785         */

   786         void RaisePostCaptureCourtesyUI();

   787 

   788         /**

   789         * Hide the optional UI in precapture

   790         * @since 3.0

   791         */

   792         void SubmergePreCaptureCourtesyUI();

   793 

   794         /**

   795         * Hide the optional UI in postcapture

   796         * @since 3.0

   797         */

   798         void SubmergePostCaptureCourtesyUI();

   799 

   800         /**

   801         * Ensures the zoom pane gets shown and updated, specifically in direct viewfinder/active toolbar modes. Calling this method

   802         * is not sufficient to show the zoom pane however, other methods in CZoomPane must be called to achieve this.

   803         * @param aRedraw Whether to force a redraw event

   804         * @since 3.0

   805         */

   806         void ShowZoomPane( TBool aRedraw );

   807         

   808         /**

   809         * Ensures the zoom pane gets hidden, specifically in direct viewfinder/active toolbar modes. As above, not sufficient to 

   810         * hide the zoom pane.

   811         * @param aRedraw Whether to force a redraw event

   812         * @since 3.0

   813         */

   814         void HideZoomPane( TBool aRedraw );

   815 

   816         /**

   817         * Refreshes the CBA based on current view and app state

   818         * @since 2.8

   819         */       

   820         void UpdateCba();

   821 

   822         /**

   823         * Sets the softkeys to the specified Resource ID

   824         * @since 3.0

   825         * @param aResource ID of the softkey resource to use

   826         */

   827         void SetSoftKeysL( TInt aResource );

   828         

   829         /**

   830         * Returns whether the time lapse slider is shown

   831         * @since 3.0

   832         * @return ETrue if time lapse slider is shown

   833         */

   834         TBool TimeLapseSliderShown() const;

   835 

   836         /**

   837         * Detects whether the direct viewfinder is in use or not

   838         * @since 3.0

   839         * @return True if it is active, otherwise false

   840         */

   841         TBool IsDirectViewfinderActive();

   842 

   843         /**

   844         * Let the AppUi know what is being shown in pre-capture

   845         * @param aMode What's being shown

   846         */

   847         void SetPreCaptureModeL(TCamPreCaptureMode aMode);  

   848 

   849         /**

   850          * Let the AppUi know what is being shown in pre-capture

   851          * @param aMode What's being shown

   852          */

   853         void SetPreCaptureMode(TCamPreCaptureMode aMode);

   854         

   855         /**

   856         * Whether or not the telephone application is in the foreground

   857         * @since 3.0

   858         * @return ETrue if the telephone application is in the foreground

   859         */    

   860         TBool ForegroundAppIsPhoneApp() const;

   861 

   862         /**

   863         * Whether to show the post capture view in current mode

   864         * @return ETrue iff we should show the post capture view in current mode

   865         */    

   866         TBool ShowPostCaptureView() const;

   867 

   868         /**

   869          * Whether the automatic UI-rise should be suppressed on next viewfinder start event

   870          * e.g. when postcapture is set to off, the UI is off and a photo is taken

   871          * @return Whether the automatic UI-rise should be suppressed

   872          */

   873         TBool SuppressUIRiseOnViewfinderStart() const;

   874 

   875         /**

   876          * Set whether the automatic UI-rise should be suppressed on next viewfinder start event

   877          * @see SuppressUIRiseOnViewfinderStart

   878          * @param aSuppress Whether the automatic UI-rise should be suppressed

   879          */

   880         void SetSuppressUIRiseOnViewfinderStart(TBool aSuppress);

   881         

   882         /**

   883         * Whether the latest capture was selftimer initiated

   884         * @return ETrue if the latest capture was started via selftimer

   885         */

   886         TBool IsSelfTimedCapture() const;

   887 

   888 

   889         /**

   890          * Set the 'freeing memory' flag.

   891          *

   892          * @param aFreeingMemory New value for the 'freeing memory' flag.

   893          */

   894         void SetFreeingMemory( TBool aFreeingMemory );

   895         

   896         /**

   897          * Get the current state of the 'freeing memory' flag.

   898          *

   899          * @return Current value for the 'freeing memory' flag.

   900          */

   901         TBool IsFreeingMemory() const;

   902 

   903         

   904         /**

   905         * Checks whether its safe to draw controls

   906         * @return ETrue if its safe to draw the controls 

   907         */

   908         TBool ReadyToDraw() const;

   909         

   910         /**

   911         * Set toolbar visibility in according to whether current view and mode are fit.

   912         */

   913         void SetToolbarVisibility();

   914 

   915         /**

   916         * Hide the toolbar.

   917         */

   918         void SubmergeToolbar(); 

   919         

   920         /**

   921         * Returns ETrue if the toolbar extension is visible,

   922         * otherwise EFalse.

   923         */

   924         TBool IsToolBarExtensionVisible() const;

   925         

   926         /*

   927          * Handles Hdmi events

   928          */

   929         void HandleHdmiEventL( TCamHdmiEvent aEvent );

   930  

   931     public: // Functions from base classes

   932         /**

   933         * Draw the counter to the bitmap used in the navi pane

   934         * @since 3.0

   935         * @param aBmpGc The graphics context for the bitmap

   936         * @param aBmpMaskGc The graphics context for the bitmap mask

   937         */

   938         void CreateNaviBitmapsL( TBool aDrawStorageIconAndCounter );

   939 	    

   940         /**

   941         * From CAknAppUi Handle user menu selections

   942         * @since 2.8

   943         * @param aCommand The enumerated code for the option selected

   944         */

   945         void HandleCommandL( TInt aCommand );

   946 

   947         /**

   948         * From MCamControllerObserver

   949         * @since 2.8

   950         * @param aEvent The enumerated code for the event received

   951         * @param aError The error code associated with the event

   952         */

   953         void HandleControllerEventL( TCamControllerEvent aEvent,

   954                                             TInt aError );

   955 

   956         /**

   957         * Return whether we are in embedded mode (if we have a pointer to a

   958         * MApaEmbeddedDocObserver).

   959         * @since 2.8

   960         * @return TBool if tthere is a handle to MApaEmbeddedDocObserver

   961         */

   962         TBool IsEmbedded() const;

   963 

   964         /**

   965         * Handle window server event.

   966         * @since 2.8

   967         * @param aEvent the window server event

   968         * @param aDestination the control associated with the event. 

   969         * Only valid for pointer events.

   970         */

   971         void HandleWsEventL( const TWsEvent& aEvent,

   972                              CCoeControl* aDestination );

   973                              

   974                              

   975         /**

   976         * Start application as file server application

   977         * @since 3.0

   978         * @param aEmbeddedObserver service observer

   979         * @param aMode Service type (image or video)

   980         */

   981         void StartAsServerAppL( MCamEmbeddedObserver *aEmbeddedObserver, 

   982         	               TInt aMode );

   983         

   984         /**

   985         * Set application file server observer  

   986         * @since 9.2

   987         * @param aEmbeddedObserver service observer

   988         */

   989         void SetEmbeddedObserver( MCamEmbeddedObserver* aEmbeddedObserver );

   990 

   991         /**

   992         * Closes the application

   993         * @since 2.8

   994         */

   995         void CloseAppL(); 

   996         

   997         /**

   998         * Closes the application

   999         * @since 2.8

  1000         * Exits the application according to current state, if the app always

  1001         * running flag is set, the application goes to the background but if 

  1002         * embedded, or app always running flag is not set or in an error situation 

  1003         * the application truly exits

  1004         */

  1005         void InternalExitL();

  1006 

  1007         /**

  1008         * Inform the controller of the count of images required at the next

  1009         * capture. Called before every still capture request.

  1010         * @since 2.8

  1011         */

  1012         void InitCaptureCountL();

  1013 

  1014         /**

  1015 		* From MCamVolumeKeyObserver - pick up volume key events

  1016 		* @since 3.1

  1017 		* @param aOperationId - operation id (i.e. volume key up/down)

  1018 		* @param aButtonAct bitton action press/click/release

  1019 		*/

  1020 		void HandleVolumeKeyEvent( TRemConCoreApiOperationId aOperationId,

  1021                             	   TRemConCoreApiButtonAction aButtonAct);

  1022                           			

  1023         /**

  1024         * Handle an event from CCamSelfTimer.   

  1025         * @since S60 v5.0

  1026         * @param aEvent the self timer event

  1027         * @param aCountDown self timer countdown duration

  1028         */

  1029         void HandleSelfTimerEvent( TCamSelfTimerEvent aEvent, 

  1030                                    TInt aCountDown );

  1031 

  1032   

  1033     public: // new fuctions

  1034 

  1035         /**

  1036         * We handle the case when settings plugin exists

  1037         **/

  1038         void SettingsPluginExitedL( TCamSettingsPluginExitMessage aType ); 

  1039 

  1040         /**

  1041         * We keep track of lauching settings plugin within camera

  1042         * to control the behaviour of the camera when the plugin exists and

  1043         * returns to camera

  1044         **/

  1045         TBool SettingsLaunchedFromCamera() const;

  1046         

  1047         /**

  1048         * Checks if the memory type is full or unavailable

  1049         * @param aStorage TCamMediaStorage enum specifying the memory type; 

  1050         *	default=ECamMediaStorageCurrent

  1051         * @return ETrue if the specified memory is full or unavailable

  1052         **/

  1053         TBool 

  1054         IsMemoryFullOrUnavailable(const TCamMediaStorage 

  1055         						  aStorage = ECamMediaStorageCurrent) const;

  1056         

  1057         /**

  1058         * Checks if all memories are full and unavailable

  1059         * @return ETrue if all memories are full or unavailable

  1060         **/

  1061         TBool AllMemoriesFullOrUnavailable() const;

  1062         

  1063         /**

  1064         * Checks the availability of memory on the currently selected 

  1065         * mediastorage for capturing images or video, result saved

  1066         * in iMemoryAvailableForCapturing

  1067         **/

  1068         void CheckMemoryAvailableForCapturing();

  1069         

  1070         /**

  1071         * Returns the previously saved availability of memory

  1072         * @return ETrue if memory available for capturing

  1073         **/

  1074         TBool IsMemoryAvailableForCapturing() const;

  1075 

  1076         /**

  1077         * Get a pointer to the startup logo controller.

  1078         * AppUi keeps ownership.

  1079         * @return Pointer to CCamStartupLogoController or NULL.

  1080         */

  1081         CCamStartupLogoController* StartupLogoController();

  1082         

  1083         /**

  1084         * Get a pointer to the NaviProgressBarModel.

  1085         */

  1086         CCamNaviProgressBarModel* NaviProgressBarModel();

  1087 

  1088     private: // New functions

  1089 

  1090       /**

  1091       * Helper method to handle controller event for

  1092       * going to standby mode.

  1093       */

  1094       void HandleStandbyEventL( TInt aStatus );

  1095             

  1096       /**

  1097       * Notify our views of application level events, like focus gained/lost.

  1098       */

  1099       void NotifyViews( const TCamAppEvent& aEvent );

  1100 

  1101 

  1102         /**

  1103         * Construct views

  1104         * Construct pre capture views        

  1105         * @since 2.8

  1106         */

  1107         void ConstructPreCaptureViewsL();

  1108 

  1109         /**

  1110         * Construct post capture views

  1111         * @since 2.8

  1112         */

  1113         void ConstructPostCaptureViewsL();

  1114 

  1115         /**

  1116         * Construct settings, user scene setup, and postcapture views 

  1117         * @since 2.8

  1118         */

  1119         void ConstructViewIfRequiredL();

  1120 

  1121         /**

  1122         * Construct navi pane

  1123         * @since 2.8

  1124         */

  1125         void ConstructNaviPaneL();

  1126 

  1127         /**

  1128         * Switch to pre-capture view

  1129         * @since 2.8

  1130         * @return TInt to indicate if function should be called again

  1131         */

  1132         TInt DoPostCaptureTimeoutL();

  1133 

  1134         /**