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 // This needs to be included first, because other include files

    20 // may be variated using these flags.

    21 #include <avkon.hrh>

    22 #include <barsread.h>  // TResourceReader

    23 #include <StringLoader.h>

    24 #include <sysutil.h>

    25 #include <eikenv.h>

    26 #include <hlplch.h>

    27 #include <apgwgnam.h>

    28 #include <apgcli.h>

    29 #include <DocumentHandler.h>

    30 #include <apmstd.h>

    31 #include <textresolver.h>

    32 #include <aknnotewrappers.h>

    33 #include <akntitle.h>  // CAknTitlePane

    34 #include <aknclearer.h>

    35 #include <aknnavide.h>

    36 #include <AknWaitDialog.h>

    37 #include <aknstaticnotedialog.h>

    38 #include <AknCapServerDefs.h>

    39 #include <akntoolbar.h>

    40 #include <aknstyluspopupmenu.h>

    41 #include <aknlayoutscalable_apps.cdl.h>

    42 #include <akntoolbarextension.h>

    43 #include <eiksoftkeypostingtransparency.h>

    44 #include <centralrepository.h>

    45 #include <AknSgcc.h>

    46 #include <cameraapp.rsg>

    47 #include <vgacamsettings.rsg>

    48 #include <activepalette2ui.h>

    49 #include <AknGlobalNote.h>

    50 #include <hal.h>

    51 #include <hal_data.h>

    52 #include <oommonitorsession.h>

    53 #include <driveinfo.h>

    54 #include <pathinfo.h>

    55 #include <AccMonitor.h>

    56 

    57 #ifndef __WINSCW__

    58 //#include <SFIUtilsAppInterface.h>

    59 #endif

    60 

    61 #include <musresourceproperties.h>

    62 #include <cameraplatpskeys.h>

    63 

    64 #include <AknCommonDialogsDynMem.h>

    65 #include <CAknMemorySelectionDialogMultiDrive.h>

    66 #include <aknmessagequerydialog.h>

    67 

    68 #include "CameraappPrivateCRKeys.h"

    69 #include "CamAppUi.h"

    70 #include "CamUtility.h"

    71 #include "CamAppController.h"

    72 #include "CamControllerObservers.h"

    73 #include "CamTimer.h"

    74 #include "CamLogger.h"

    75 #include "CamStillPreCaptureView.h"

    76 #include "CamStillPostCaptureView.h"

    77 #include "CamVideoPreCaptureView.h"

    78 #include "CamVideoPostCaptureView.h"

    79 #include "CamBurstThumbnailView.h"

    80 #include "CamSelfTimer.h"

    81 #include "CamPanic.h"

    82 #include "CamBurstModeObserver.h"

    83 #include "CamStillUserSceneSetupView.h"

    84 #include "CamNaviCounterControl.h"

    85 #include "CamNaviCounterModel.h"

    86 #include "CamNaviProgressBarControl.h"

    87 #include "Cam.hrh"

    88 #include "CamSettings.hrh"

    89 #include "CamProductSpecificSettings.hrh"

    90 #include "CamAppUiBase.h"

    91 #include "CamWaitDialog.h"

    92 #include "CamSidePane.h"

    93 #include "CamZoomPane.h"

    94 #include "CamAppUid.h"

    95 #include <csxhelp/lcam.hlp.hrh>

    96 #include "CameraVariant.hrh"

    97 #include "OstTraceDefinitions.h"

    98 #ifdef OST_TRACE_COMPILER_IN_USE

    99 #include "CamAppuiTraces.h"

   100 #endif

   101 #include "camactivepalettehandler.h"

   102 #include "CamContainerBase.h"

   103 #include "camuidconstants.h"

   104 #include "CamGSInterface.h"

   105 #include "CamFileCheckAo.h"

   106 #include "CamLocalViewIds.h"

   107 #include "CameraUiConfigManager.h"

   108 

   109 #include "MCamAddToAlbumObserver.h"

   110 #include "CamCollectionManagerAo.h"

   111 #include "glxgallery.hrh"

   112 #include "glxcollectionplugincamera.hrh"

   113 #include "s32mem.h"

   114 

   115 

   116 #include "camflashstatus.h"

   117 #include "CamMemoryMonitor.h"

   118 #include "camstartuplogocontroller.h"

   119 

   120 

   121 

   122 // ===========================================================================

   123 // Constants

   124 

   125 // Sequence mode related constants that define the amount of pictures taken

   126 // with sequence mode.

   127 const TInt KShortBurstCount  = 18;   // number of images captured during burst

   128 

   129 // When asked if current memory is full in video mode

   130 // there needs to be at least following amount of recording

   131 // time left or memory is said to be full.

   132 const TTimeIntervalMicroSeconds KMemoryFullVideoRemaining = 1000*1000;

   133 

   134 // This is used to find the window group id for Eikon Server.

   135 // The Eikon Server window group id is later used to ignore all window server

   136 // events saying Eikon Server has gained focus.

   137 _LIT( KEikonServer, "EikonServer" );

   138 

   139 _LIT8(K3gpVideoMimeType, "video/3gpp");

   140 _LIT8(KMp4VideoMimeType, "video/mp4");

   141 

   142 //const TCamMediaStorage KCamInternalStorage = ECamMediaStoragePhone;

   143 

   144 const TUint KCameraEventInterest = ( ECamCameraEventClassBasicControl

   145                                    | ECamCameraEventClassImage

   146                                    | ECamCameraEventClassVideo

   147                                    | ECamCameraEventClassVfControl

   148                                    | ECamCameraEventClassSsControl

   149                                    | ECamCameraEventClassSettings );

   150 /**

   151  * class CCamFtuDisplay

   152  * This class is used to give a notification to Camera First Time User regarding the 

   153  * geotagging of captured images or videos.

   154  */

   155 

   156 class CCamFtuDisplay : public CAsyncOneShot 

   157     {

   158 public:

   159     /**

   160      * CCamFtuDisplay

   161      * Default Constructor

   162      */

   163     CCamFtuDisplay( CCamAppUi * aCamAppUi )

   164     : CAsyncOneShot( CActive::EPriorityLow), iCamAppUi(aCamAppUi)

   165             {

   166             }

   167     enum TEnableCamFtu

   168         {

   169         ECamFtuEnable = 0,

   170         ECamFtuDisable

   171         };

   172     

   173 protected:

   174     /**

   175      * RunL

   176      * Callback method

   177      */

   178     void RunL()

   179         {

   180         iCamAppUi->CamFtuDisplayL();

   181         }

   182 private:

   183     /**

   184      * iCamAppUi

   185      * An instance of the CCamAppUi

   186      */

   187     CCamAppUi* iCamAppUi;

   188     };

   189 

   190 

   191 // ===========================================================================

   192 // Member functions

   193 

   194 // -----------------------------------------------------------------------------

   195 // CCamAppUi::~CCamAppUi

   196 // Destructor

   197 // -----------------------------------------------------------------------------

   198 //

   199 CCamAppUi::~CCamAppUi()

   200     {

   201     PRINT( _L("Camera => ~CCamAppUi" ))

   202     if ( iMemoryMonitor )

   203         {

   204         iMemoryMonitor->StopMonitoring();

   205         delete iMemoryMonitor;

   206         iMemoryMonitor = 0;

   207         }

   208 

   209     delete iStartupLogoController;

   210 

   211     iController.SetAppUiAvailable( EFalse );

   212 

   213     iResourceLoaders.Close();

   214 

   215 #ifdef CAMERAAPP_DELAYED_POSTCAPTURE_CREATION

   216     if( iPostCapIdle )

   217         {

   218         iPostCapIdle->Cancel();

   219         delete iPostCapIdle;

   220         }

   221 #endif

   222 

   223     if ( iFileCheckAo )

   224         {

   225         iFileCheckAo->Cancel();

   226         delete iFileCheckAo;	

   227         }

   228 

   229     if ( iController.UiConfigManagerPtr()->IsOrientationSensorSupported() &&

   230          iSensorIdle )

   231         {

   232         CancelSensorIdle();

   233         delete iSensorIdle;

   234         }  

   235 

   236 #if !defined(__WINSCW__)

   237     // relinquish capture keys

   238     UnRegisterCaptureKeys();    

   239 #endif

   240 

   241     SaveCaptureMode();

   242     SaveCourtesyUiState();

   243 

   244     delete iDecoratedNaviPaneCounter;

   245     delete iDecoratedNaviPaneProgressBar;

   246 #if defined( CAMERAAPP_CAPI_V2_DVF )

   247     if ( iSelfTimer )

   248         {

   249         iSelfTimer->RemoveObserver( this );

   250         }

   251 #endif // CAMERAAPP_CAPI_V2_DVF

   252     delete iSelfTimer;

   253     delete iParentAppName;

   254     delete iTextResolver;

   255 

   256     iController.RemoveControllerObserver( this );

   257 

   258     // Burst mode observers are not owned, delete only the pointers to them.

   259     iBurstModeObservers.Close();

   260 

   261     if ( iWaitTimer && iWaitTimer->IsActive() )

   262         {

   263         iWaitTimer->Cancel();

   264         }

   265     delete iWaitTimer;

   266     delete iDocHandler;

   267     delete iCamSidePane;

   268     delete iCamZoomPane;       

   269 

   270     delete iRepository;

   271 

   272 /*#ifndef __WINSCW__

   273     delete iSFIUtils;

   274 #endif*/

   275 

   276     delete iNaviCounterControl;

   277     delete iNaviProgressBarControl;

   278     delete iNaviCounterModel;

   279     delete iNaviProgressBarModel;  

   280     delete iActivePaletteHandler;

   281     iActivePaletteHandler = NULL;

   282 

   283     if( iCourtesyTimer )

   284         {

   285         iCourtesyTimer->Cancel();

   286         }

   287     delete iCourtesyTimer;

   288     delete iScreenClearer;

   289     delete iVolumeKeyObserver;

   290 

   291     delete iCollectionManager;

   292     iCollectionManager = NULL;

   293 

   294     if( iCamFtuDisplay )

   295         {

   296         delete iCamFtuDisplay;

   297         iCamFtuDisplay = NULL;

   298         }

   299 

   300     PRINT( _L("Camera <= ~CCamAppUi" ))

   301     }

   302 

   303 // -----------------------------------------------------------------------------

   304 // CCamAppUi::ConstructL

   305 // Symbian 2nd phase constructor can leave.

   306 // -----------------------------------------------------------------------------

   307 //

   308 void CCamAppUi::ConstructL()

   309   {

   310   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP2_CCAMAPPUI_CONSTRUCTL, "e_CCamAppUi_ConstructL 1" );

   311   PRINT( _L("Camera => CCamAppUi::ConstructL") )

   312   iRotatedKeyEvent = ETrue;

   313   iReturnedFromPlugin = EFalse;

   314   iController.SetAppUiAvailable( ETrue );

   315 

   316   iLockedQwertyState = E2ndCamUnknown; 

   317   iMemoryMonitor = CCamMemoryMonitor::NewL( this, &iController );

   318 

   319   TInt memError =

   320   iMemoryMonitor->CheckAndRequestMemoryL( iController.UiConfigManagerPtr()->CriticalLevelRamMemory(),

   321                                           iController.UiConfigManagerPtr()->RequiredRamMemory(),

   322                                           ETrue );

   323 

   324 

   325   TInt freeMemory = 0;

   326   HAL::Get( HALData::EMemoryRAMFree, freeMemory );

   327   if ( memError && freeMemory < iController.UiConfigManagerPtr()->CriticalLevelRamMemoryFocusGained() )

   328       {

   329       User::Leave( memError );

   330       }

   331   iUiConstructionComplete = EFalse;

   332   iDSASupported = iController.UiConfigManagerPtr()->IsDSAViewFinderSupported();

   333   

   334   TBool uiOrientationOverride = iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported();

   335   

   336   // Get the screenmode values used for setting  the orientation

   337   RArray<TInt> screenModeValues;

   338   if ( uiOrientationOverride )

   339       {

   340       iController.UiConfigManagerPtr()->SupportedScreenModesL( screenModeValues );

   341       iLandscapeScreenMode = screenModeValues[0];

   342       iPortraitScreenMode = screenModeValues[1];

   343       }

   344   

   345   // The embedded views are set after ConstructL completes

   346   // but the value is only of interest if the app is embedded

   347   iEmbeddedViewSet = !IsEmbedded();

   348   PRINT1( _L("Camera => CCamAppUi::ConstructL iEmbeddedViewSet:%d"), iEmbeddedViewSet );

   349   

   350   // In embedded case requesting new file without defined resolution

   351   // the 0*0 is interpreted as the default mms size resolution

   352   iRequestedNewFileResolution.SetSize( 0, 0 );

   353 

   354   // Camera window group id

   355   iMyWgId = iCoeEnv->RootWin().Identifier();

   356 

   357   // Get the id of Eikon Server window group

   358   iEikonServerWindowGroupId = iCoeEnv->WsSession().FindWindowGroupIdentifier(

   359     0,

   360     KEikonServer );

   361   

   362   CApaWindowGroupName::FindByAppUid(

   363     KBtNotifierServerUid,

   364     iCoeEnv->WsSession(),

   365     iBTServerWindowGroupId);

   366 

   367   CApaWindowGroupName::FindByAppUid(

   368     KPhoneAppUid,

   369     iCoeEnv->WsSession(),

   370     iPhoneAppWindowGroupId);

   371 

   372   PRINT( _L("Camera <> create new repository") );

   373   TInt crValue = 0;

   374   if( !iRepository )

   375     {

   376     iRepository = CRepository::NewL( KCRUidCameraappSettings ); 

   377     }

   378 

   379   // get softkey position

   380   CamUtility::GetPsiInt( ECamPsiSoftKeyPosition, iSoftkeyPosition );

   381   

   382   iCamOrientation = ReadCurrentDeviceOrientation();

   383   PRINT1( _L("Camera <> CurrentDeviceOrientation (%d)"), iCamOrientation )

   384   PERF_EVENT_START_L2( EPerfEventAvkonUIConstruction );  

   385   TInt orientation;

   386   if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() )

   387       {

   388       PRINT( _L("Camera <> using slider position to set orientation") );

   389       // Use the current slider position for the required orientation

   390       TInt sliderPosition;

   391       TInt err = RProperty::Get(

   392             CameraPlatPSKeys::KPSCameraPlatUid,

   393             CameraPlatPSKeys::KLensCoverStatus,

   394             sliderPosition );  

   395       

   396       // ToDo this could be removed after PCFW has released new implementation (wk25/2009)

   397       if( err == KErrNotFound )

   398           {

   399           PRINT( _L("Camera <> using slider position to set orientation") );

   400           err = RProperty::Get(

   401               NMusResourceApi::KCategoryUid,

   402               NMusResourceApi::KCameraAvailability,

   403               sliderPosition );  

   404           }

   405       PRINT2( _L("Camera <> slider position = %d, error = %d"),

   406             sliderPosition, err );

   407   

   408       // If there is an error then assume the slider is closed (as long as there is

   409       // more than one camera) 

   410       if ( err )

   411         {

   412         PRINT1( _L("Camera <> Slider status err%d - Check status later"),err )

   413         iController.SetCameraSwitchRequired( ESwitchToUnknown );

   414         }

   415       if ( ( ( CCamAppController::CamerasAvailable() > 1 && 

   416              sliderPosition == CameraPlatPSKeys::EClosed ) || 

   417            err != KErrNone ) && !IsQwerty2ndCamera( ETrue ) ) 

   418           {

   419           PRINT( _L("Camera <> setting orientation for secondary camera") )

   420           CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, orientation );

   421           }

   422       else

   423           {

   424           PRINT( _L("Camera <> setting orientation for primary camera") )

   425           CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, orientation );    

   426           } 

   427       }

   428   else

   429       {

   430       // Without lens cover support, always start to primary camera

   431       CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, orientation );

   432       }

   433 

   434   if ( orientation == ( TInt ) EAppUiOrientationLandscape )

   435     {

   436     PRINT( _L("Camera <> orientation is landscape ") )

   437     iCamOrientation = (ECamHandLeft == iSoftkeyPosition ) 

   438                     ? ECamOrientationCamcorderLeft 

   439                     : ECamOrientationCamcorder;

   440 

   441     PRINT( _L("Camera <> Calling BaseConstructL") )

   442     OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 1" ); //CCORAPP_APP_BASE_CONSTRUCT_START

   443     BaseConstructL( EAppOrientationLandscape | EAknEnableSkin | EAknEnableMSK | 

   444                     ENonStandardResourceFile | EAknSingleClickCompatible );

   445     OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 0" );    //CCORAPP_APP_BASE_CONSTRUCT_END

   446     PRINT( _L("Camera <> BaseConstructL Complete") )

   447                             

   448     if( uiOrientationOverride )

   449       {

   450       // Finish engine construction

   451       iController.CompleteConstructionL();  

   452       //set orientation to CCamera	

   453       iController.SetCameraOrientationModeL( iLandscapeScreenMode );

   454       // and complete the cameracontroller construction

   455       iController.CompleteCameraConstructionL();

   456       }

   457     }

   458   else

   459     {

   460     PRINT( _L("Camera <> orientation is portrait") )

   461     iCamOrientation = ECamOrientationPortrait;

   462     

   463     PRINT( _L("Camera <> Calling BaseConstructL") )

   464     OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 1" );

   465     BaseConstructL( EAppOrientationPortrait | EAknEnableSkin | EAknEnableMSK | 

   466                     ENonStandardResourceFile );  

   467     OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 0" );

   468     PRINT( _L("Camera <> BaseConstructL Complete") )

   469     

   470     if( uiOrientationOverride )

   471       {

   472       // Finish engine construction

   473       iController.CompleteConstructionL();  

   474       //set orientation to CCamera	

   475       iController.SetCameraOrientationModeL( iPortraitScreenMode );

   476       // and complete the cameracontroller construction

   477       iController.CompleteCameraConstructionL();

   478       }     

   479     }

   480 

   481     PERF_EVENT_END_L2( EPerfEventAvkonUIConstruction );

   482 

   483 #if !defined (__WINSCW__)

   484 #if !( defined(__WINS__) || defined(__WINSCW__) )

   485   // Ensure that the macro switch keys are always captured by this

   486   // application.

   487   if ( !AppInBackground( EFalse ) )  //camera is constructed in background

   488      {

   489       RegisterCaptureKeysL();

   490      }

   491 #endif // !defined(__WINS__) || defined(__WINSCW__)    

   492 #endif

   493 

   494   if( !uiOrientationOverride )

   495     {

   496     // Load the settings model static settings

   497     PRINT( _L("Camera <> call CCamAppController::LoadStaticSettingsL..") )

   498     iController.LoadStaticSettingsL( IsEmbedded() );

   499   

   500     // Check the screen size if it matches the orientation we expect.

   501     // If not, delay the initialization until HandleScreenDeviceChangedL is called.

   502     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP6_CCAMAPPUI_CONSTRUCTL, "e_ReadUiOrientationFromWindowServer 1" );

   503     TSize screenSize = iCoeEnv->ScreenDevice()->SizeInPixels();

   504     PRINT2( _L("<> CCamAppUi::ConstructL() iCoeEnv->ScreenDevice()->SizeInPixels():  w=%d h=%d"), screenSize.iWidth, screenSize.iHeight );

   505     TBool expectLandscape = (iCamOrientation != ECamOrientationPortrait);

   506     TBool isLandscape     = (screenSize.iWidth > screenSize.iHeight);

   507     if( isLandscape != expectLandscape || AppInBackground( EFalse ) )   //screen is not ready or camera app is in background

   508       {

   509       iEngineConstructionDelayed = ETrue;

   510       }

   511 

   512 OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP7_CCAMAPPUI_CONSTRUCTL, "e_ReadUiOrientationFromWindowServer 0" );

   513 

   514     // initialise the self timer mode 

   515     iInSelfTimerMode = ECamSelfTimerDisabled;

   516 

   517     if ( !iEngineConstructionDelayed )     

   518       {

   519     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP8_CCAMAPPUI_CONSTRUCTL, "e_EngineConstructionDelayed 1" );

   520       iController.CompleteConstructionL();

   521       iController.StoreUserSceneSettingsL();

   522     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP9_CCAMAPPUI_CONSTRUCTL, "e_EngineConstructionDelayed 0" );

   523 

   524       } 

   525     }

   526   else

   527     {

   528     iEngineConstructionDelayed = EFalse;    

   529     iInSelfTimerMode = ECamSelfTimerDisabled;

   530     }

   531   

   532   

   533   iEmbeddedObserver = NULL;

   534   

   535   iController.AddControllerObserverL( this );

   536   iController.AddCameraObserverL( this, KCameraEventInterest );

   537   

   538   if( !uiOrientationOverride )

   539     {

   540 /*#ifndef __WINSCW__

   541     // Initialize SFIUtils

   542   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP10_CCAMAPPUI_CONSTRUCTL, "e_InitSendFileInCall 1" );

   543 	PRINT(_L("iSFIUtils = CSFIUtilsAppInterface::NewL -->"));

   544     TRAPD(errSFI,iSFIUtils = CSFIUtilsAppInterface::NewL());

   545 	PRINT1(_L("iSFIUtils = CSFIUtilsAppInterface::NewL <-- errSFI=%d"),errSFI);

   546 	User::LeaveIfError(errSFI);

   547     iSendFileInCall = EFalse;

   548   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP11_CCAMAPPUI_CONSTRUCTL, "e_InitSendFileInCall 0" );

   549     PRINT( _L("iSendFileInCall = EFalse") );

   550 #endif*/

   551 

   552     // Create text resolver for error note text

   553     iTextResolver = CTextResolver::NewL();

   554 

   555     ConstructPreCaptureViewsL();

   556   

   557     iSelfTimer = CCamSelfTimer::NewL( iController );

   558 #if defined( CAMERAAPP_CAPI_V2_DVF )

   559     iSelfTimer->AddObserverL( this ); 

   560 #endif // CAMERAAPP_CAPI_V2_DVF

   561 

   562     PRINT( _L("Camera <> creating navicounter model") );

   563     iNaviCounterModel = CCamNaviCounterModel::NewL( iController );

   564     PRINT( _L("Camera <> append navicounter to resourceloaders") );

   565     User::LeaveIfError( iResourceLoaders.Append(iNaviCounterModel) );

   566   

   567     PRINT( _L("Camera <> creating progress bar model") );

   568     iNaviProgressBarModel = CCamNaviProgressBarModel::NewL( iController );

   569     PRINT( _L("Camera <> append progressbar to resourceloaders") );

   570     User::LeaveIfError(iResourceLoaders.Append(iNaviProgressBarModel));

   571   

   572     ConstructNaviPaneL();

   573     }

   574 

   575   

   576   iRepository->Get( KCamCrAlwaysDrawCourtesyUi, crValue );

   577   iAlwaysDrawPreCaptureCourtesyUI = (crValue == KCamCrAlwaysDrawCourtesyUiIsOn);

   578 

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

   580 

   581 

   582   if( uiOrientationOverride )

   583     {

   584     // always start in still mode	

   585     iMode = ECamControllerImage;

   586     iTargetMode = ECamControllerImage;	

   587     }

   588   else

   589     {  

   590     // If the view launch needs to wait until the engine

   591     // is constructed or the embedded launch view is set, the starting

   592     // state will be standby    

   593     if ( !IsConstructionComplete() )

   594       {

   595       iViewState = ECamViewStateStandby;

   596       }

   597 

   598     // Get start up mode from settings.

   599     // If the application is embedded the new view will be set

   600     // when HandleNewFileL is called by the framework

   601     PRINT( _L("Camera <> CCamAppUi::ConstructL set default view") );

   602     if ( StartupMode() == ECamStillCapture )

   603       {

   604       iMode = ECamControllerImage;

   605       iTargetMode = ECamControllerImage;

   606       SetDefaultViewL( *iStillCaptureView );

   607       }

   608     else

   609       {

   610       iMode = ECamControllerVideo;

   611       iTargetMode = ECamControllerVideo;

   612       SetDefaultViewL( *iVideoCaptureView );

   613       }      

   614 

   615 

   616     if( !iEngineConstructionDelayed )

   617       {

   618       // pre-construct side-pane & zoom pane

   619       // get whether we overlay sidepane over view-finder

   620       TBool overlayViewFinder;

   621       User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiOverLaySidePane, overlayViewFinder ) );

   622       PRINT( _L("Camera <> CCamAppUi::ConstructL create sidepane") );

   623       iCamSidePane = CCamSidePane::NewL( iController, overlayViewFinder );

   624       User::LeaveIfError(iResourceLoaders.Append(iCamSidePane));

   625     

   626       PRINT( _L("Camera <> CCamAppUi::ConstructL create zoom pane") );

   627       iCamZoomPane = CCamZoomPane::NewL( iController, overlayViewFinder );

   628       User::LeaveIfError(iResourceLoaders.Append(iCamZoomPane));

   629       }

   630   }  

   631   // create the timer used for callbacks

   632   iWaitTimer = CPeriodic::NewL( CActive::EPriorityHigh );

   633 

   634  

   635   // initialise the view construction states

   636   iPostCaptureViewsConstructed     = EFalse;

   637   iUserSceneSetupViewConstructed   = EFalse;

   638   iCustomiseToolbarViewConstructed = EFalse;

   639   

   640   if( !uiOrientationOverride )

   641     {  

   642     PRINT( _L("Camera => CCamAppUi::ConstructL create doc handler") );

   643     iDocHandler = CDocumentHandler::NewL( CEikonEnv::Static()->Process() );

   644     iDocHandler->SetExitObserver(this);

   645   iController.CheckMemoryToUseL();

   646   

   647     // create navi-pane and navi-porgress bar for use in camcorder mode 

   648     PRINT( _L("Camera => CCamAppUi::ConstructL create navicounter control") );

   649     iNaviCounterControl = CCamNaviCounterControl::NewL( *iNaviCounterModel );

   650     iNaviCounterControl->SetExtentToWholeScreen();

   651   

   652     PRINT( _L("Camera => CCamAppUi::ConstructL create progress bar control") );

   653     iNaviProgressBarControl = CCamNaviProgressBarControl::NewL( *iNaviProgressBarModel );        

   654   

   655     // get max num of images for burst capture

   656     CamUtility::GetPsiInt( ECamPsiMaxBurstCapture, iMaxBurstCaptureNum );

   657   

   658     PRINT( _L("Camera => CCamAppUi::ConstructL create AP handler") );

   659     iActivePaletteHandler = CCamActivePaletteHandler::NewL( iController, EFalse );

   660     }

   661       

   662   iDrawPreCaptureCourtesyUI = ETrue;

   663   iDrawPostCaptureCourtesyUI = ETrue;

   664   iAlwaysDrawPostCaptureCourtesyUI = ETrue;

   665   iLeftSoftKeyPressed = EFalse;

   666   if( !uiOrientationOverride )

   667     {

   668     // get coutesy UI timeout

   669     TInt timeoutValue;

   670     CamUtility::GetPsiInt( ECamPsiCourtesyUiTimeoutValue, timeoutValue );

   671   

   672     iCourtesyTimer = CCamTimer::NewL( timeoutValue * 1000000, 

   673                                       TCallBack( CCamAppUi::CourtesyTimeout, this ) );

   674 

   675     PRINT( _L("Camera => CCamAppUi::ConstructL update navi models") );

   676     UpdateNaviModelsL();

   677     PRINT( _L("Camera => CCamAppUi::ConstructL navi counter reload resources") );

   678     iNaviCounterModel->ReloadResourceDataL();

   679     PRINT( _L("Camera => CCamAppUi::ConstructL navi progress bar reload resources") );

   680     iNaviProgressBarModel->ReloadResourceDataL();

   681     }

   682       

   683   iZoomPaneShown = EFalse;

   684   iFirstBoot = ETrue; // Show zoom

   685   iProcessingScreenRedraw = EFalse;

   686   iSendAsInProgress = EFalse;

   687   

   688   if( !uiOrientationOverride )

   689     {  

   690     iFileCheckAo = CCamFileCheckAo::NewL( iController, *this );  

   691     iCollectionManager = new (ELeave) CCamCollectionManagerAO( *this );

   692     }

   693 

   694   iCheckOperationInProgress = EFalse;

   695   iLostFocusToNewWindow = EFalse;

   696   iFirstVFStart = ETrue;

   697 

   698   if ( !uiOrientationOverride )

   699     {

   700     iUiConstructionComplete = ETrue;

   701     }

   702   iMemoryMonitor->StartMonitoring( iController.UiConfigManagerPtr()->CriticalLevelRamMemoryFocusGained(),

   703                                    iController.UiConfigManagerPtr()->RequiredRamMemoryFocusGained() );

   704 

   705   // TRAP errors so camera starts up even if startup animation fails

   706   TRAP_IGNORE(iStartupLogoController = CCamStartupLogoController::NewL(EStartupLogoVisible));

   707 

   708   PRINT( _L("Camera <= CCamAppUi::ConstructL") )

   709   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP3_CCAMAPPUI_CONSTRUCTL, "e_CCamAppUi_ConstructL 0" );

   710    

   711   //  To get FTU flag value

   712 

   713     TInt ftuValue=0;

   714     TInt retErr=0;

   715     retErr=iRepository->Get( KCamCrFtuMessageFlag, ftuValue );

   716    

   717     if( !IsEmbedded() && ftuValue == CCamFtuDisplay::ECamFtuEnable 

   718 	        && retErr==KErrNone )

   719         {

   720         iCamFtuDisplay = new (ELeave)CCamFtuDisplay(this);

   721         iCamFtuDisplay->Call();

   722         }

   723     }

   724     

   725 

   726 

   727 // -----------------------------------------------------------------------------

   728 // IsInternalView

   729 // -----------------------------------------------------------------------------

   730 //

   731 TBool CCamAppUi::IsInternalView( TCamViewState aViewState ) const

   732   {

   733   PRINT1( _L("Camera => CCamAppUi::IsInternalView [%s]"), KCamViewStateNames[aViewState] );

   734 

   735   TBool internal( EFalse );

   736 

   737   if ( aViewState < ECamViewStateRangeInternalMax

   738     && aViewState > ECamViewStateRangeInternalMin )

   739       {

   740       internal = ETrue;

   741       }

   742   else if( aViewState < ECamViewStateRangeExternalMax

   743         && aViewState > ECamViewStateRangeExternalMin )

   744       {

   745       internal = EFalse;

   746       }

   747   else

   748     {

   749     CamPanic( ECamPanicInvalidView );

   750     }

   751 

   752   PRINT1( _L("Camera <= CCamAppUi::IsInternalView, return %d"), internal );

   753   return internal;

   754   }

   755 // -----------------------------------------------------------------------------

   756 // CCamAppUi:: HyperlinkCallback

   757 // Call back method for the hyper link text 

   758 // -----------------------------------------------------------------------------

   759 //

   760 TInt CCamAppUi:: HyperlinkCallback(TAny* aAny)

   761     {

   762     (static_cast<CCamAppUi*>(aAny))->OpenSettingView();

   763     return EFalse;

   764     }

   765 // -----------------------------------------------------------------------------

   766 // CCamAppUi::OpenSettingView

   767 // Non static public method , to launch the settings view

   768 // -----------------------------------------------------------------------------

   769 //

   770 void CCamAppUi::OpenSettingView()

   771     {

   772     TRAP_IGNORE( HandleCommandL( ECamCmdSettings ) );

   773     }

   774 // -----------------------------------------------------------------------------

   775 // CCamAppUi::CamFtuDisplayL()

   776 // TO Display FTU message for first time camera launched

   777 // -----------------------------------------------------------------------------

   778 //

   779 void CCamAppUi::CamFtuDisplayL()

   780     {    

   781 

   782 	iController.SetIntegerSettingValueL( ECamSettingItemRecLocation, ECamLocationOn );

   783 

   784     CAknMessageQueryDialog* dlg =

   785     new (ELeave) CAknMessageQueryDialog();

   786     dlg->PrepareLC( R_FTU_MESSAGE_DIALOG );

   787     HBufC* msg = iEikonEnv->AllocReadResourceLC( R_FTU_MESSAGE_DIALOG_TEXT );

   788     HBufC* hyperLinkMsg = iEikonEnv->AllocReadResourceLC(

   789             R_FTU_MESSAGE_HYPERLINK_TEXT );

   790    

   791     TInt len = msg->Length() 

   792             + hyperLinkMsg->Length() 

   793             + KOpeningLinkTag().Length() 

   794             + KClosingLinkTag().Length();

   795     

   796     HBufC* displayMsg = HBufC::NewLC( len );

   797     _LIT(KMsgFormat, "%S%S%S%S");

   798     displayMsg->Des().Format(KMsgFormat, 

   799             msg, 

   800             &KOpeningLinkTag(),

   801             hyperLinkMsg,

   802             &KClosingLinkTag());

   803 

   804     dlg->SetMessageTextL( *displayMsg );

   805     CleanupStack::PopAndDestroy(3); //msg, hyperLinkMsg, displayMsg

   806     

   807     TCallBack callback( HyperlinkCallback, this );

   808 

   809     dlg->SetLink( callback );

   810 

   811     dlg->RunLD();

   812 

   813     iRepository->Set( KCamCrFtuMessageFlag, CCamFtuDisplay::ECamFtuDisable );

   814 

   815 	//Read the location record value in case its changed by hyperlink

   816 

   817 	TInt value = 0;

   818 	iRepository->Get( KCamCrPhotoStoreLocation, value );

   819 	iController.SetIntegerSettingValueL( ECamSettingItemRecLocation, value );

   820 	

   821     } 

   822 // -----------------------------------------------------------------------------

   823 // CCamAppUi::IsConstructionComplete

   824 // Returns whether or not all construction has completed

   825 // -----------------------------------------------------------------------------

   826 //    

   827 TBool CCamAppUi::IsConstructionComplete() const

   828     {     

   829     TBool complete = ETrue;

   830     complete = !iEngineConstructionDelayed;

   831     return complete && iEmbeddedViewSet; 

   832     }

   833 

   834     

   835 // -----------------------------------------------------------------------------

   836 // CCamAppUi::NaviCounter

   837 // Returns the pointer to the NaviCounter control

   838 // -----------------------------------------------------------------------------

   839 //

   840 CCamNaviCounterControl* CCamAppUi::NaviCounterControl()

   841     {

   842     return iNaviCounterControl;

   843     }

   844     

   845 // -----------------------------------------------------------------------------

   846 // CCamAppUi::NaviProgressBar

   847 // Returns the pointer to the NaviProgress control

   848 // -----------------------------------------------------------------------------

   849 //

   850 CCamNaviProgressBarControl* CCamAppUi::NaviProgressBarControl()

   851     {

   852     return iNaviProgressBarControl;

   853     }

   854 

   855 // -----------------------------------------------------------------------------

   856 // CCamAppUi::NaviCounterModel

   857 // Returns the pointer to the NaviCounter model

   858 // -----------------------------------------------------------------------------

   859 //    

   860 CCamNaviCounterModel* CCamAppUi::NaviCounterModel()

   861     {

   862     return iNaviCounterModel;

   863     }

   864 

   865 

   866 // -----------------------------------------------------------------------------

   867 // CCamAppUi::CCamAppUi

   868 // C++ default constructor can NOT contain any code, that

   869 // might leave.

   870 // -----------------------------------------------------------------------------

   871 //

   872 CCamAppUi::CCamAppUi( CCamAppController& aController )                              

   873     : iController( aController ),

   874     iViewState( ECamViewStatePreCapture ),

   875     iTargetViewState( ECamViewStatePreCapture ), 

   876     iPreventActivePaletteDisplay( EFalse ),

   877     iInternalStorage(ECamMediaStorageNone)

   878     {

   879     }

   880 

   881 // ----------------------------------------------------

   882 // CCamAppUi::SetTitleL

   883 // Set title pane text from a resource.

   884 // ----------------------------------------------------

   885 //

   886 void CCamAppUi::SetTitleL( TInt aResourceId )

   887     {

   888     // Set title

   889     CAknTitlePane* title = static_cast<CAknTitlePane*>(

   890         StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

   891     TResourceReader reader;

   892     iCoeEnv->CreateResourceReaderLC( reader, aResourceId );

   893     title->SetFromResourceL( reader );

   894     CleanupStack::PopAndDestroy();  // resource reader

   895     }

   896 

   897 // ----------------------------------------------------

   898 // CCamAppUi::SetTitleL

   899 // Set title pane text from a descriptor.

   900 // ----------------------------------------------------

   901 //

   902 void CCamAppUi::SetTitleL( const TDesC& aText )

   903     {

   904     CAknTitlePane* title = static_cast<CAknTitlePane*>(

   905         StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

   906     title->SetTextL( aText );

   907     }

   908 

   909 

   910 

   911 // ----------------------------------------------------

   912 // CCamAppUi::PushNaviPaneCounterL

   913 // Push navi pane counter on to navi pane stack.

   914 // ----------------------------------------------------

   915 //

   916 void 

   917 CCamAppUi::PushNaviPaneCounterL()

   918   {

   919   iNaviCounterModel->SetCaptureModeL( iMode, iImageMode );

   920   iDecoratedNaviPaneCounter->MakeScrollButtonVisible( EFalse );

   921   NaviPaneL()->PushL( *iDecoratedNaviPaneCounter );

   922   }

   923 

   924 // ----------------------------------------------------

   925 // CCamAppUi::PushNaviPaneProgressBarL

   926 // Push navi pane progress bar on to navi pane stack.

   927 // ----------------------------------------------------

   928 //

   929 void CCamAppUi::PushNaviPaneProgressBarL()

   930     {

   931     iDecoratedNaviPaneProgressBar->MakeScrollButtonVisible( EFalse );

   932     NaviPaneL()->PushL( *iDecoratedNaviPaneProgressBar );

   933     }

   934 

   935 // ----------------------------------------------------

   936 // CCamAppUi::PushDefaultNaviPaneL

   937 // Push default navi pane on to navi pane stack.

   938 // ----------------------------------------------------

   939 //

   940 void CCamAppUi::PushDefaultNaviPaneL()

   941     {

   942     NaviPaneL()->PushDefaultL();

   943     }

   944 

   945 

   946 // ----------------------------------------------------

   947 // CCamAppUi::DisplayDeleteNoteL

   948 // Call DisplayDeleteNoteL on the current view

   949 // ----------------------------------------------------

   950 //

   951 TBool CCamAppUi::DisplayDeleteNoteL()

   952   {

   953   TBool deleted = 

   954           static_cast<CCamPostCaptureViewBase*>( iView )->DisplayDeleteNoteL();

   955 

   956   // If the image/video has been deleted, switch view

   957   if ( deleted )

   958     {

   959                               

   960     if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() && IsEmbedded() )

   961         {

   962         // if in embedded mode, then check the status of the slide

   963         // and set a pending camera switch if the slide has been

   964         // opened/closed after starting the capture

   965         iController.CheckSlideStatus();

   966         }      

   967                                

   968     // if this is burst mode and there are still images left, 

   969     // return to thumbnail view

   970     if ( ECamImageCaptureBurst == iController.CurrentImageModeSetup()

   971       && 0                     <  iController.CurrentItemCount() )

   972       {

   973       iTargetViewState = ECamViewStateBurstThumbnail;

   974       }

   975     // otherwise switch to pre-capture view

   976     else

   977       {

   978       iTargetViewState = ECamViewStatePreCapture;

   979       }

   980     TrySwitchViewL();

   981     }

   982   else

   983     {

   984     }

   985   return deleted;

   986   }

   987 

   988 // ----------------------------------------------------

   989 // CCamAppUi::SelfTimerEnableL

   990 // Enable or disable SelfTimer functionality

   991 // ----------------------------------------------------

   992 //

   993 void CCamAppUi::SelfTimerEnableL( TCamSelfTimerFunctions aState )

   994     {

   995     // If the requested state is the current state, do nothing.

   996     if ( iInSelfTimerMode == aState )

   997         {

   998         return;

   999         }

  1000 

  1001     __ASSERT_DEBUG( iSelfTimer, CamPanic( ECamPanicNullPointer ) );

  1002 

  1003     // Update the member variable

  1004     iInSelfTimerMode = aState;

  1005 

  1006     if ( aState != ECamSelfTimerDisabled  )

  1007         {     

  1008         // Set up for current timer mode

  1009         iSelfTimer->SetModeL( iMode, iImageMode, iInSelfTimerMode );              

  1010         UpdateCba();

  1011         }

  1012     else                

  1013         {

  1014         // stop the timer and remove the indicator from the side pane

  1015         iSelfTimer->Cancel();

  1016 

  1017         // In capture setup mode, toolbar and indicators are not visible

  1018         // They will be updated when returning to precap, similarily to

  1019         // when setting the self timer mode above

  1020         // during changing from still pre-capture view to video pre-capture view, no need 

  1021         // to show toolbar of still image. It will display toolbar of video when entering video pre-capture  

  1022 

  1023         if( ( iPreCaptureMode != ECamPreCapCaptureSetup && 

  1024               iPreCaptureMode != ECamPreCapSceneSetting ) &&                           

  1025             !( IsViewFinderInTransit() && 

  1026                 iMode == ECamControllerImage &&

  1027                 iTargetMode == ECamControllerVideo ) )    

  1028             {

  1029             // Re-show the active palette

  1030             iActivePaletteHandler->UpdateActivePaletteL();

  1031             iPreventActivePaletteDisplay = EFalse;

  1032             SetActivePaletteVisibility( ETrue );

  1033             

  1034             if ( iController.IsTouchScreenSupported() )

  1035                 {

  1036                 CAknToolbar* toolbar = CurrentFixedToolbar();

  1037                 if (toolbar)

  1038                     {

  1039                     toolbar->SetToolbarVisibility( ETrue );

  1040                     }

  1041                 }

  1042             // Cancel any active focusing operation

  1043             // this won't cancel if capture has already been requested

  1044             iController.CancelFocusAndCapture();

  1045                 

  1046             iStillCaptureView->UpdateToolbarIconsL();

  1047             

  1048             // Raise precapture UI and restart courtesy UI timer,

  1049             // if hide icons is enabled.

  1050             RaisePreCaptureCourtesyUI(EFalse);        

  1051             }        

  1052         

  1053         UpdateCba();

  1054         CCamViewBase* precapView = static_cast<CCamViewBase*>( iView );              

  1055         if( precapView && 

  1056             IsViewFinderInTransit() && 

  1057             iMode == ECamControllerImage &&

  1058             iTargetMode == ECamControllerVideo )

  1059           {

  1060           precapView->ViewCba()->DrawNow();       

  1061           }

  1062         }    

  1063     }

  1064 

  1065 // -----------------------------------------------------------------------------

  1066 // CCamAppUi::SelfTimerEnabled

  1067 // Returns current self-timer state

  1068 // -----------------------------------------------------------------------------

  1069 //        

  1070 TBool CCamAppUi::SelfTimerEnabled() const

  1071     {

  1072     return ( iInSelfTimerMode != ECamSelfTimerDisabled );

  1073     }

  1074 

  1075 // -----------------------------------------------------------------------------

  1076 // CCamAppUi::SelfTimer

  1077 // Returns pointer to self-timer object

  1078 // -----------------------------------------------------------------------------

  1079 //        

  1080 CCamSelfTimer* CCamAppUi::SelfTimer()

  1081     {

  1082     return iSelfTimer;

  1083     }

  1084 

  1085 // -----------------------------------------------------------------------------

  1086 // CCamAppUi::AddBurstModeObserverL

  1087 // Register an observer for burst mode changes

  1088 // -----------------------------------------------------------------------------

  1089 // 

  1090 void 

  1091 CCamAppUi::AddBurstModeObserverL( MCamBurstModeObserver* aBurstModeObserver )

  1092   {

  1093   // Check for non-null and only add once.

  1094   if( aBurstModeObserver &&

  1095      KErrNotFound == iBurstModeObservers.Find( aBurstModeObserver ) )

  1096     {

  1097     iBurstModeObservers.AppendL( aBurstModeObserver );

  1098     }

  1099   }

  1100 

  1101 // -----------------------------------------------------------------------------

  1102 // CCamAppUi::RemoveBurstModeObserver

  1103 // Remove the burst mode observer

  1104 // -----------------------------------------------------------------------------

  1105 //

  1106 void

  1107 CCamAppUi::RemoveBurstModeObserver( const MCamBurstModeObserver* aBurstModeObserver )

  1108   {

  1109   if( aBurstModeObserver )

  1110     {

  1111     TInt index = iBurstModeObservers.Find( aBurstModeObserver );

  1112     if( KErrNotFound != index )

  1113       {

  1114       iBurstModeObservers.Remove( index );

  1115       }

  1116     }

  1117   }

  1118 

  1119 // -----------------------------------------------------------------------------

  1120 // CCamAppUi::IsBurstEnabled

  1121 // Return burst mode enabled state

  1122 // -----------------------------------------------------------------------------

  1123 //

  1124 TBool CCamAppUi::IsBurstEnabled() const

  1125   {

  1126   PRINT_FRQ( _L("Camera => CCamAppUi::IsBurstEnabled" ) )

  1127   TBool ret = EFalse;

  1128   if ( ECamImageCaptureBurst     == iImageMode 

  1129     || ECamImageCaptureTimeLapse == iImageMode )

  1130     {

  1131     ret = ETrue;

  1132     }

  1133 

  1134   PRINT_FRQ( _L("Camera <= CCamAppUi::IsBurstEnabled" ) )