1 /*

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

    72 // ===========================================================================

    73 // CLASS DECLARATION

    74 

    75 /**

    76 *  AppUi class for Camera

    77 *

    78 *  @since 2.8

    79 */

    80 class CCamAppUi : public CCamAppUiBase,

    81                   public MCamSelfTimerObserver,

    82                   public MCamControllerObserver,

    83                   public MCamVolumeKeyObserver,

    84                   public MCamFileCheckObserver,

    85                   public MCamCameraObserver

    86                   ,public MCamAddToAlbumObserver

    87   {

    88   // =======================================================

    89   // Data Types

    90   private: 

    91         

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

    93     // the capture mode or view state changes

    94     enum TCamViewSwitch

    95         {

    96         ECamViewSwitchNone,    // no switch required

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

    98         ECamViewSwitch         // full view switch required including state 

    99                                // and mode update

   100         };

   101 

   102     /**

   103      * Enumeration used for the state of delayed postacapture views

   104      * construction. Only used if CAMERAAPP_DELAYED_POSTCAPTURE_CREATION is

   105      * enabled.

   106      */

   107     enum TCamPostCapConstruction

   108         {    

   109         ECamConstructStillPostCap,

   110         ECamConstructBurstPostCap,

   111         ECamConstructVideoPostCap,

   112         ECamPostCapsDone

   113         };

   114     

   115     enum TSoftkeyIndex

   116         {

   117         ESoftkeyIndex1 = 0,

   118         ESoftkeyIndex2 = 2

   119         };

   120       

   121     enum TPendingViewSwitchType 

   122         {

   123         EPendingViewSwitchNone = 0,

   124         EPendingViewSwitchNormal,

   125         EPendingViewSwitchDeactivateFirst

   126         };

   127 

   128     /**

   129      * Memory card status

   130      */

   131     enum TCamMemoryStatus

   132         {

   133         ECamMemoryStatusOK,

   134         ECamMemoryStatusFull,

   135         ECamMemoryStatusInternalFull,

   136         ECamMemoryStatusCardNotInserted,

   137         ECamMemoryStatusCardReadOnly,

   138         ECamMemoryStatusCardLocked,

   139         ECamMemoryStatusMassStorageFull

   140         };

   141 

   142   // =======================================================

   143   // Methods 

   144 

   145   // -------------------------------------------------------

   146   // Constructors and destructor

   147   public:  

   148 

   149     /**

   150     * C++ constructor.

   151     * @since 2.8

   152     * @param aController Reference to CCamAppController

   153     * @return Pointer to CCamAppUi

   154     */

   155     CCamAppUi( CCamAppController& aController );

   156 

   157     /**

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

   159     * @since 2.8

   160     */

   161     void ConstructL();

   162 

   163     /**

   164     * Destructor.

   165     */

   166     virtual ~CCamAppUi();

   167   

   168   // -------------------------------------------------------

   169   // From MCamCameraObserver

   170   public:

   171 

   172     /**

   173     * Handle camera event.

   174     *

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

   176     * @param aEventId   Identifier for the event.

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

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

   179     *                   particular event id.

   180     *                   Ownership not transferred to observer.

   181     */

   182     void HandleCameraEventL(

   183         TInt aStatus, 

   184         TCamCameraEventId aEventId, 

   185         TAny* aEventData = NULL );   

   186 

   187   // -------------------------------------------------------

   188   // From MCamFileCheckObserver

   189   public:

   190 

   191     /**

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

   193     * @param aStatus Number of files that were missing

   194     * @param aError  Error code

   195     */

   196     void FileCheckingCompleteL( TInt aStatus, TInt aError );   

   197 

   198   // -------------------------------------------------------

   199   // New functions

   200   public: 

   201       /**

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

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

   204       * @since 3.2

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

   206       */

   207       virtual TBool IsToolBarVisible() const;

   208 

   209         /**

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

   211         * CCamViewBase inherited view is in question.

   212         */

   213         TBool IsInternalView( TCamViewState aViewState ) const;

   214 

   215         /**

   216         * Set status of standby mode.

   217         */

   218         void SetStandbyStatus( TInt aStatus );

   219 

   220         /**

   221         * Get status of standby mode.

   222         */

   223         TInt StandbyStatus() const;

   224 

   225         /*

   226         * Check for file name deletion/renaming outside camera

   227         */

   228         void StartFileNameCheck();

   229              

   230         /**

   231         * Determines whether or not all construction has been completed

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

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

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

   235         * when launched in embedded

   236         * @since 3.0

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

   238         */   

   239         TBool IsConstructionComplete() const;

   240 

   241         /**

   242         * Set title pane text from a resource.

   243         * @since 2.8

   244         * @param aResourceId resource to read from

   245         */

   246         void SetTitleL( TInt aResourceId );

   247 

   248         /**

   249         * Set title pane text from a descriptor.

   250         * @since 2.8

   251         * @param aText title pane text

   252         */

   253         void SetTitleL( const TDesC& aText );

   254 

   255         /**

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

   257         * @since 2.8

   258         */

   259         void SetTitleEmbeddedL();

   260 

   261         /**

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

   263         * @since 2.8

   264         */

   265         void PushNaviPaneCounterL();

   266 

   267         /**

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

   269         * @since 2.8

   270         */

   271         void PushNaviPaneProgressBarL();

   272 

   273         /**

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

   275         * @since 2.8

   276         */

   277         void PushDefaultNaviPaneL();

   278 

   279         /**

   280         * Call DisplayDeleteNoteL on the current view

   281         * @return whether the delete was performed

   282         * @since 2.8

   283         */

   284         TBool DisplayDeleteNoteL();

   285 

   286         /**

   287         * Enable or disable self-timer functionality

   288         * @since 2.8

   289         * @param aEnable The selftimer functionality to use

   290         */

   291         void SelfTimerEnableL( TCamSelfTimerFunctions aEnable );

   292 

   293         /**

   294         * Returns current self-timer state

   295         * @since 2.8

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

   297         */

   298         TBool SelfTimerEnabled() const;

   299 

   300         /**

   301         * Returns pointer to self-timer

   302         * @since 2.8

   303         * @return pointer to CCamSelfTimer object.

   304         */

   305         CCamSelfTimer* SelfTimer();

   306 

   307         /**

   308         * Registers an observer for changes in burst mode activation

   309         * @since 2.8

   310         * @param aBurstModeObserver the object observing burst mode changes

   311         */

   312         void AddBurstModeObserverL( MCamBurstModeObserver* aBurstModeObserver );

   313 

   314         /**

   315         * Removes an observer for changes in burst mode activation

   316         * @since 2.8

   317         * @param aBurstModeObserver the observer to remove

   318         */

   319         void RemoveBurstModeObserver( const MCamBurstModeObserver* aBurstModeObserver );

   320 

   321         /**

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

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

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

   325         * @since 2.8

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

   327         */

   328         TBool IsBurstEnabled() const;

   329 

   330         /*

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

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

   333         */

   334         MCamAppController& AppController();

   335         

   336         /*

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

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

   339         */

   340         MCamStaticSettings& StaticSettingsModel();

   341         

   342         /**

   343         * Returns the currently enabled burst mode.

   344         * @since 3.0

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

   346         * burst is not enabled

   347         */

   348         TCamImageCaptureMode CurrentBurstMode() const;

   349 

   350         /**

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

   352         * @since 2.8

   353         */

   354         void SetCaptureMode(

   355             TCamCameraMode aMode, 

   356             TCamImageCaptureMode aImageMode = ECamImageCaptureNone );

   357 

   358         /**

   359         * Changes the state of sequence capture

   360         * @since 3.0

   361         * @param aImageMode Single/Multi/Timelapse

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

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

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

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

   366         * to default value (single capture).

   367         */ 

   368         void SwitchStillCaptureModeL( TCamImageCaptureMode aImageMode, 

   369                                       TBool                aReprepare, 

   370                                       TBool                aUpdateUi = ETrue );

   371 

   372 

   373         /**

   374         * Returns whether or the secondary camera has been activated

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

   376         * @since 2.8

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

   378         */

   379         TBool IsSecondCameraEnabled() const;

   380 

   381         /**

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

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

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

   385         * @param aLock, Lock orientation state flag. 

   386         *               ETrue, ask state and lock it.

   387         *               EFalse, ask current state.

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

   389         */

   390         TBool IsQwerty2ndCamera( TBool aLock = EFalse );  

   391 

   392         /**

   393         * 

   394         * @return ETrue if wait dialog exist

   395         */

   396         TBool CCamAppUi::IsWaitDialog() const;

   397 

   398         /**

   399         * Returns the active camera

   400         * @since 2.8

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

   402         */

   403         TCamActiveCamera ActiveCamera() const;

   404 

   405         /**

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

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

   408         * @since 2.8

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

   410         */

   411         TBool CheckMemoryL();

   412 

   413         /**

   414         * Display error note - with OK softkey only

   415         * @since 2.8

   416         * @param aStatus error status

   417         */

   418         void ShowErrorNoteL( TCamMemoryStatus aStatus );

   419 

   420         /**

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

   422         * @since 2.8

   423         * @param aLabel text to be shown

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

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

   426         */

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

   428 

   429         /**

   430         * Set the requested resolution for a new file

   431         * @since 3.2

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

   433         */

   434         void SetRequestedNewFileResolution( const TSize& aRequestedResolution );

   435 

   436         /**

   437         * Get the requested resolution for a new file

   438         * @since 3.2

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

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

   441         */

   442         TSize RequestedNewFileResolution() const;

   443 

   444         /**

   445         * Shows the mmc removal note if it is required

   446         * @since 2.8

   447         */

   448         void ShowMMCRemovalNoteIfRequiredL();

   449 

   450         /**

   451         * Check memory card for available space and card status

   452         * @since 2.8

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

   454         * @param aStatus on return contains the card status

   455         * @param aCurrentLocation current storage location

   456         */

   457         void CheckMemoryCard( TBool& aFull,

   458                 TCamMemoryStatus& aStatus, TCamMediaStorage aCurrentLocation );

   459 

   460         /**

   461         * Checks if aStorage location is full

   462         * @since 2.8

   463         * @param aStorage target storage location

   464         * @param aCurrentLocation current storage location

   465         * @return ETrue if aStorage location is full

   466         */

   467         TBool MemoryFull( TCamMediaStorage aStorage, TCamMediaStorage aCurrentLocation );

   468 

   469         /**

   470         * Starts the video/photo capture

   471         * @since 2.8

   472         * @param aKeyEvent Key used to start the capture

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

   474         */

   475         TKeyResponse StartCaptureL( const TKeyEvent& aKeyEvent );

   476 

   477         /**

   478         * Stops the video capture

   479         * @since 2.8

   480         */

   481         void EndCapture();

   482         

   483         /**

   484         * Changes the orientation to aNewOrientation

   485         * If aNewOrientation is EAppUiOrientationUnspecified, switches

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

   487         * activated camera)

   488         * @since 3.0

   489         */

   490         void SwitchOrientationIfRequiredL( TInt aNewOrientation );

   491 

   492         /**

   493         * Returns pointer to side-pane

   494         * @since 2.8

   495         * @return pointer to CCamSidePane object constructed by appUi

   496         */

   497         CCamSidePane* SidePane();

   498 

   499         /**

   500         * Returns pointer to zoom-pane

   501         * @since 2.8

   502         * @return pointer to CCamZoomPane object constructed by appUi

   503         */

   504         CCamZoomPane* ZoomPane();

   505 

   506         /**

   507         * Returns current camera orientation

   508         * @since 3.0

   509         * @return current camera orientation

   510         */

   511         TCamOrientation CamOrientation();

   512 

   513         /**

   514         * set current camera orientation as landscape

   515         */

   516         void SetCamOrientationToLandscape();

   517 	

   518         /**

   519         * Returns current viewstate

   520         * @since 3.0

   521         * @return current viewstate

   522         */

   523         TCamViewState CurrentViewState() const;

   524         

   525         /**

   526         * Returns target view state

   527         * @since 4.0

   528         * @return target view state

   529         */

   530         TCamViewState TargetViewState();

   531 

   532         /**

   533         * Returns the target mode of current mode switch

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

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

   536         * in progress

   537         */        

   538         TCamCameraMode TargetMode() const;

   539 

   540         /**

   541         * Handles the shutter key press

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

   543         * @since 2.8

   544         */

   545         void HandleShutterKeyL( TBool aPressed );    

   546         

   547         /**

   548         * Set embedding flag 

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

   550         * EFalse if not

   551         * @since 2.8

   552         */

   553         void SetEmbedding( TBool aEmbedding );

   554         

   555         /**

   556         * Return embedding flag 

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

   558         * EFalse if not

   559         * @since 2.8

   560         */

   561         TBool Embedding() const;

   562         

   563         /**

   564         * Set SendAs flag 

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

   566         * @since 2.8

   567         */

   568         void SetSendAsInProgressL( TBool aSendAsInProgress );

   569 

   570         /**

   571         * Get SendAs flag value 

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

   573         * @since 4.0

   574         */        

   575         virtual TBool SendAsInProgress() const;

   576         

   577         /**

   578         * Offers a pointer to appui's TextResolver instance

   579         * @return pointer to appui's TextResolver instance   

   580         */

   581         CTextResolver* TextResolver();

   582             

   583 #ifndef __WINSCW__

   584         /**

   585         * Get pointer to SFI utility class 

   586         * @since 3.0

   587         * @return pointer to CSFIUtilsAppInterface

   588         */

   589         //CSFIUtilsAppInterface* SFIUtility() const;

   590 

   591         /**

   592         * Return whether we are currently in-call send

   593         * @since 3.0

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

   595         */

   596         //TBool IsInCallSend() const;

   597 

   598         /**

   599         * Send media file using SFI utility

   600         * @since 3.0

   601         */

   602         //void DoInCallSendL() const;

   603 #endif //WINSCW

   604 

   605         /**

   606         * Whether or not the application is in the background

   607         * @since 2.8

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

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

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

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

   612         */   

   613         TBool AppInBackground( TBool aIncludeNotifier ) const;

   614         

   615         /**

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

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

   618         */

   619         TBool IsInPretendExit() const;

   620 

   621         /**

   622         * Returns whether an MMC removed note is pending

   623         * @since 3.0

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

   625         */

   626         TBool IsMMCRemovedNotePending() const;                  

   627 

   628         /**

   629         * Returns the pointer to the NaviCounter pane

   630         * @since 3.0

   631         * @return The Navi Counter pointer

   632         */

   633         CCamNaviCounterControl* NaviCounterControl();

   634         

   635         /**

   636         * Returns the pointer to the NaviProgress pane

   637         * @since 3.0

   638         * @return The Navi Progress pointer

   639         */

   640         CCamNaviProgressBarControl* NaviProgressBarControl();

   641 

   642         /**

   643         * Returns the pointer to the Navi Counter ModelProgress pane

   644         * @since 3.0

   645         * @return The Navi Counter Model pointer

   646         */

   647         CCamNaviCounterModel* NaviCounterModel();

   648 

   649         /**

   650         * Return handle to active palette if supported

   651         * @since 3.0

   652         * @return Handle to Active palette

   653         */             

   654         MActivePalette2UI* ActivePalette() const;

   655         

   656         /**

   657         * Get pointer to Active Palette handler instance.

   658         *

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

   660         *         transferred.

   661         */

   662         CCamActivePaletteHandler* APHandler() const;

   663 

   664         /**

   665         * Tries to show or hide the Active Toolbar

   666         * @since 3.0

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

   668         */

   669         void SetActivePaletteVisibility( TBool aShown );

   670 

   671         /**

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

   673         * @since 3.0

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

   675         */

   676         TBool AlwaysDrawPreCaptureCourtesyUI() const;

   677 

   678         /**

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

   680         * @since 3.0

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

   682         */

   683         TBool AlwaysDrawPostCaptureCourtesyUI() const;

   684 

   685         /**

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

   687         * @since 3.0

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

   689         */

   690         void  SetAlwaysDrawPreCaptureCourtesyUI( TBool aNewSetting );

   691 

   692         /**

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

   694         * @since 3.0

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

   696         */

   697         void SetAlwaysDrawPostCaptureCourtesyUI( TBool aNewSetting );

   698 

   699         /**

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

   701         * @since 3.0

   702         * @param aKeyEvent The key event

   703         * @param aType The type of key event

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

   705         * @return Whether the key was consumed or not

   706         */

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

   708 

   709         /**

   710         * Whether to draw the complete UI in precapture mode

   711         * @since 3.0

   712         * @return True if it should all be drawn

   713         */

   714         TBool DrawPreCaptureCourtesyUI() const;

   715 

   716         /**

   717         * Whether to draw the complete UI in postcapture mode

   718         * @since 3.0

   719         * @return True if it should all be drawn

   720         */

   721         TBool DrawPostCaptureCourtesyUI() const;

   722 

   723         /**

   724         * Bring the complete UI to the fore in precapture

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

   726         * @since 3.0

   727         */

   728         void RaisePreCaptureCourtesyUI(TBool aShowZoomBar);

   729 

   730         /**

   731         * Bring the complete UI to the fore in postcapture

   732         * @since 3.0

   733         */

   734         void RaisePostCaptureCourtesyUI();

   735 

   736         /**

   737         * Hide the optional UI in precapture

   738         * @since 3.0

   739         */

   740         void SubmergePreCaptureCourtesyUI();

   741 

   742         /**

   743         * Hide the optional UI in postcapture

   744         * @since 3.0

   745         */

   746         void SubmergePostCaptureCourtesyUI();

   747 

   748         /**

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

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

   751         * @param aRedraw Whether to force a redraw event

   752         * @since 3.0

   753         */

   754         void ShowZoomPane( TBool aRedraw );

   755         

   756         /**

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

   758         * hide the zoom pane.

   759         * @param aRedraw Whether to force a redraw event

   760         * @since 3.0

   761         */

   762         void HideZoomPane( TBool aRedraw );

   763 

   764         /**

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

   766         * @since 2.8

   767         */       

   768         void UpdateCba();

   769 

   770         /**

   771         * Sets the softkeys to the specified Resource ID

   772         * @since 3.0

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

   774         */

   775         void SetSoftKeysL( TInt aResource );

   776         

   777         /**

   778         * Returns whether the time lapse slider is shown

   779         * @since 3.0

   780         * @return ETrue if time lapse slider is shown

   781         */

   782         TBool TimeLapseSliderShown() const;

   783 

   784         /**

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

   786         * @since 3.0

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

   788         */

   789         TBool IsDirectViewfinderActive();

   790 

   791         /**

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

   793         * @param aMode What's being shown

   794         */

   795         void SetPreCaptureModeL(TCamPreCaptureMode aMode);  

   796 

   797         /**

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

   799          * @param aMode What's being shown

   800          */

   801         void SetPreCaptureMode(TCamPreCaptureMode aMode);

   802         

   803         /**

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

   805         * @since 3.0

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

   807         */    

   808         TBool ForegroundAppIsPhoneApp() const;

   809 

   810         /**

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

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

   813         */    

   814         TBool ShowPostCaptureView() const;

   815 

   816         /**

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

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

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

   820          */

   821         TBool SuppressUIRiseOnViewfinderStart() const;

   822 

   823         /**

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

   825          * @see SuppressUIRiseOnViewfinderStart

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

   827          */

   828         void SetSuppressUIRiseOnViewfinderStart(TBool aSuppress);

   829         

   830         /**

   831         * Whether the current capture was selftimer initiated

   832         * @return ETrue if the current capture was started via selftimer

   833         */

   834         TBool IsSelfTimedCapture() const;

   835 

   836 

   837         /**

   838          * Set the 'freeing memory' flag.

   839          *

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

   841          */

   842         void SetFreeingMemory( TBool aFreeingMemory );

   843         

   844         /**

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

   846          *

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

   848          */

   849         TBool IsFreeingMemory() const;

   850 

   851         

   852         /**

   853         * Checks whether its safe to draw controls

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

   855         */

   856         TBool ReadyToDraw() const;

   857         

   858         /**

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

   860         */

   861         void SetToolbarVisibility();

   862 

   863         /**

   864         * Hide the toolbar.

   865         */

   866         void SubmergeToolbar(); 

   867  

   868     public: // Functions from base classes

   869         /**

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

   871         * @since 3.0

   872         * @param aBmpGc The graphics context for the bitmap

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

   874         */

   875         void CreateNaviBitmapsL( TBool aDrawStorageIconAndCounter );

   876 	    

   877         /**

   878         * From CAknAppUi Handle user menu selections

   879         * @since 2.8

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

   881         */

   882         void HandleCommandL( TInt aCommand );

   883 

   884         /**

   885         * From MCamControllerObserver

   886         * @since 2.8

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

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

   889         */

   890         void HandleControllerEventL( TCamControllerEvent aEvent,

   891                                             TInt aError );

   892 

   893         /**

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

   895         * MApaEmbeddedDocObserver).

   896         * @since 2.8

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

   898         */

   899         TBool IsEmbedded() const;

   900 

   901         /**

   902         * Handle window server event.

   903         * @since 2.8

   904         * @param aEvent the window server event

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

   906         * Only valid for pointer events.

   907         */

   908         void HandleWsEventL( const TWsEvent& aEvent,

   909                              CCoeControl* aDestination );

   910                              

   911                              

   912         /**

   913         * Start application as file server application

   914         * @since 3.0

   915         * @param aEmbeddedObserver service observer

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

   917         */

   918         void StartAsServerAppL( MCamEmbeddedObserver *aEmbeddedObserver, 

   919         	               TInt aMode );

   920 

   921         /**

   922         * Closes the application

   923         * @since 2.8

   924         */

   925         void CloseAppL(); 

   926         

   927         /**

   928         * Closes the application

   929         * @since 2.8

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

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

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

   933         * the application truly exits

   934         */

   935         void InternalExitL();

   936 

   937         /**

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

   939         * capture. Called before every still capture request.

   940         * @since 2.8

   941         */

   942         void InitCaptureCountL();

   943 

   944         /**

   945 		* From MCamVolumeKeyObserver - pick up volume key events

   946 		* @since 3.1

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

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

   949 		*/

   950 		void HandleVolumeKeyEvent( TRemConCoreApiOperationId aOperationId,

   951                             	   TRemConCoreApiButtonAction aButtonAct);

   952                           			

   953         /**

   954         * Handle an event from CCamSelfTimer.   

   955         * @since S60 v5.0

   956         * @param aEvent the self timer event

   957         * @param aCountDown self timer countdown duration

   958         */

   959         void HandleSelfTimerEvent( TCamSelfTimerEvent aEvent, 

   960                                    TInt aCountDown );

   961 

   962   

   963     public: // new fuctions

   964 

   965         /**

   966         * We handle the case when settings plugin exists

   967         **/

   968         void SettingsPluginExitedL( TCamSettingsPluginExitMessage aType ); 

   969 

   970         /**

   971         * We keep track of lauching settings plugin within camera

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

   973         * returns to camera

   974         **/

   975         TBool SettingsLaunchedFromCamera() const;

   976         

   977         /**

   978         * Checks if the memory type is full or unavailable

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

   980         *	default=ECamMediaStorageCurrent

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

   982         **/

   983         TBool 

   984         IsMemoryFullOrUnavailable(const TCamMediaStorage 

   985         						  aStorage = ECamMediaStorageCurrent) const;

   986         

   987         /**

   988         * Checks if all memories are full and unavailable

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

   990         **/

   991         TBool AllMemoriesFullOrUnavailable() const;

   992 

   993             

   994     private: // New functions

   995 

   996       /**

   997       * Helper method to handle controller event for

   998       * going to standby mode.

   999       */

  1000       void HandleStandbyEventL( TInt aStatus );

  1001             

  1002       /**

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

  1004       */

  1005       void NotifyViews( const TCamAppEvent& aEvent );

  1006 

  1007 

  1008         /**

  1009         * Construct views

  1010         * Construct pre capture views        

  1011         * @since 2.8

  1012         */

  1013         void ConstructPreCaptureViewsL();

  1014 

  1015         /**

  1016         * Construct post capture views

  1017         * @since 2.8

  1018         */

  1019         void ConstructPostCaptureViewsL();

  1020 

  1021         /**

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

  1023         * @since 2.8

  1024         */

  1025         void ConstructViewIfRequiredL();

  1026 

  1027         /**

  1028         * Construct navi pane

  1029         * @since 2.8

  1030         */

  1031         void ConstructNaviPaneL();

  1032 

  1033         /**

  1034         * Switch to pre-capture view

  1035         * @since 2.8

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

  1037         */

  1038         TInt DoPostCaptureTimeoutL();

  1039 

  1040         /**

  1041         * Try to switch active view.

  1042         * @since 2.8

  1043         */

  1044         void TrySwitchViewL( TBool aDeactivateFirst = EFalse );

  1045 

  1046         /**

  1047         * Determines if a switch of the active view required.

  1048         * @param aDeactivateFirst Deactivate before check

  1049         * @since 2.8

  1050         */

  1051         TCamViewSwitch ViewSwitchRequired( TBool aDeactivateFirst = EFalse ) const;

  1052 

  1053         /**

  1054         * Get uid of view with requested view and mode.

  1055         * @since 2.8

  1056         * @param aState      View state

  1057         * @param aMode       Main camera mode (image/video)

  1058         * @param aImageMode  In image mode, image capture type (single/burst/timelapse)

  1059         * @param aUid        Uid of view passed by reference and populated in function

  1060         * @param aMessageUid A message Uid to pass to the view

  1061         * @return            Whether or not a valid view uid can be obtained

  1062         */

  1063         TBool ViewId( TCamViewState        aState, 

  1064                              TCamCameraMode       aMode, 

  1065                              TCamImageCaptureMode aImageMode, 

  1066                              TUid&                aUid, 

  1067                              TUid&                aMessageUid,

  1068                              TBool                aDeactivateFirst );

  1069 

  1070         /**

  1071         * Return a pointer to the navi pane.

  1072         * @since 2.8

  1073         * @return pointer to the status pane's navigation control container

  1074         */

  1075         CAknNavigationControlContainer* NaviPaneL();

  1076 

  1077         /**

  1078         * Display the wait dialog when saving video

  1079         * @since 2.8

  1080         */

  1081         void DisplayWaitDialogL();

  1082 

  1083         /**

  1084         * Get the default startup mode from settings

  1085         * If this is not defined the factory default will be used

  1086         * @since 2.8

  1087         * @return The default startup capture mode

  1088         */

  1089         TCamStartupMode StartupMode() const;

  1090     

  1091         /**

  1092         * Save the current capture mode to settings.

  1093         * This will be used as the startup mode

  1094         * @since 2.8

  1095         */

  1096         void SaveCaptureMode();

  1097         

  1098         /**

  1099         * Save the current state of the UI to settings.

  1100         * 

  1101         */

  1102         

  1103         void SaveCourtesyUiState();

  1104 

  1105         /**

  1106         * Override HandleScreenDeviceChangedL() and trigger a re-layout

  1107 		* of the main controls from this - addition for 2.8

  1108         * @since 2.8

  1109         */

  1110         void HandleScreenDeviceChangedL();

  1111 

  1112         /**

  1113         * Called when the video is ready to be stopped

  1114         * @since 2.8

  1115         * @param aPtr pointer to the object that called the timer

  1116         * @return Error code

  1117         */

  1118         static TInt StopVideoRecording( TAny* aPtr );

  1119 

  1120         /**

  1121         * Called when the application is ready to exit

  1122         * @since 2.8

  1123         * @param aAny pointer to the object that called the timer

  1124         * @return Error code

  1125         */

  1126         static TInt CallExit( TAny* aAny );

  1127 

  1128         /**

  1129         * Callback used when the application needs to switch view

  1130         * @since 2.8

  1131         * @param aAny pointer to the object that called the timer

  1132         * @return Error code

  1133         */

  1134         static TInt CallSwitch( TAny* aAny );