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 // 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 

    56 #ifndef __WINSCW__

    57 //#include <SFIUtilsAppInterface.h>

    58 #endif

    59 

    60 #include <musresourceproperties.h>

    61 #include <cameraplatpskeys.h>

    62 

    63 #include <AknCommonDialogsDynMem.h>

    64 #include <CAknMemorySelectionDialogMultiDrive.h>

    65 

    66 #include "CameraappPrivateCRKeys.h"

    67 #include "CamAppUi.h"

    68 #include "CamUtility.h"

    69 #include "CamAppController.h"

    70 #include "CamControllerObservers.h"

    71 #include "CamTimer.h"

    72 #include "CamLogger.h"

    73 #include "CamStillPreCaptureView.h"

    74 #include "CamStillPostCaptureView.h"

    75 #include "CamVideoPreCaptureView.h"

    76 #include "CamVideoPostCaptureView.h"

    77 #include "CamBurstThumbnailView.h"

    78 #include "CamSelfTimer.h"

    79 #include "CamPanic.h"

    80 #include "CamBurstModeObserver.h"

    81 #include "CamStillUserSceneSetupView.h"

    82 #include "CamNaviCounterControl.h"

    83 #include "CamNaviCounterModel.h"

    84 #include "CamNaviProgressBarControl.h"

    85 #include "Cam.hrh"

    86 #include "CamSettings.hrh"

    87 #include "CamProductSpecificSettings.hrh"

    88 #include "CamAppUiBase.h"

    89 #include "CamWaitDialog.h"

    90 #include "CamSidePane.h"

    91 #include "CamZoomPane.h"

    92 #include "CamAppUid.h"

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

    94 #include "CameraVariant.hrh"

    95 #include "OstTraceDefinitions.h"

    96 #ifdef OST_TRACE_COMPILER_IN_USE

    97 #include "CamAppUiTraces.h"

    98 #endif

    99 #include "camactivepalettehandler.h"

   100 #include "CamContainerBase.h"

   101 #include "camuidconstants.h"

   102 #include "CamGSInterface.h"

   103 #include "CamFileCheckAo.h"

   104 #include "CamLocalViewIds.h"

   105 #include "CameraUiConfigManager.h"

   106 

   107 #include "MCamAddToAlbumObserver.h"

   108 #include "CamCollectionManagerAo.h"

   109 #include "glxgallery.hrh"

   110 #include "glxcollectionplugincamera.hrh"

   111 #include "s32mem.h"

   112 

   113 

   114 #include "camflashstatus.h"

   115 #include "CamMemoryMonitor.h"

   116 

   117 

   118 

   119 // ===========================================================================

   120 // Constants

   121 

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

   123 // with sequence mode.

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

   125 

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

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

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

   129 const TTimeIntervalMicroSeconds KMemoryFullVideoRemaining = 1000*1000;

   130 

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

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

   133 // events saying Eikon Server has gained focus.

   134 _LIT( KEikonServer, "EikonServer" );

   135 

   136 //const TCamMediaStorage KCamInternalStorage = ECamMediaStoragePhone;

   137 

   138 const TUint KCameraEventInterest = ( ECamCameraEventClassBasicControl

   139                                    | ECamCameraEventClassImage

   140                                    | ECamCameraEventClassVideo

   141                                    | ECamCameraEventClassVfControl

   142                                    | ECamCameraEventClassSsControl

   143                                    | ECamCameraEventClassSettings );

   144 

   145 

   146 

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

   148 // Member functions

   149 

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

   151 // CCamAppUi::~CCamAppUi

   152 // Destructor

   153 // -----------------------------------------------------------------------------

   154 //

   155 CCamAppUi::~CCamAppUi()

   156     {

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

   158     if ( iMemoryMonitor )

   159         {

   160         iMemoryMonitor->StopMonitoring();

   161         delete iMemoryMonitor;

   162         iMemoryMonitor = 0;

   163         }

   164 

   165     iController.SetAppUiAvailable( EFalse );

   166 

   167     iResourceLoaders.Close();

   168 

   169 #ifdef CAMERAAPP_DELAYED_POSTCAPTURE_CREATION

   170     if( iPostCapIdle )

   171         {

   172         iPostCapIdle->Cancel();

   173         delete iPostCapIdle;

   174         }

   175 #endif

   176 

   177     if ( iFileCheckAo )

   178         {

   179         iFileCheckAo->Cancel();

   180         delete iFileCheckAo;	

   181         }

   182 

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

   184          iSensorIdle )

   185         {

   186         CancelSensorIdle();

   187         delete iSensorIdle;

   188         }  

   189 

   190 #if !defined(__WINSCW__)

   191     // relinquish capture keys

   192     UnRegisterCaptureKeys();    

   193 #endif

   194 

   195     SaveCaptureMode();

   196     SaveCourtesyUiState();

   197 

   198     delete iDecoratedNaviPaneCounter;

   199     delete iDecoratedNaviPaneProgressBar;

   200 #if defined( CAMERAAPP_CAPI_V2_DVF )

   201     if ( iSelfTimer )

   202         {

   203         iSelfTimer->RemoveObserver( this );

   204         }

   205 #endif // CAMERAAPP_CAPI_V2_DVF

   206     delete iSelfTimer;

   207     delete iParentAppName;

   208     delete iTextResolver;

   209 

   210     iController.RemoveControllerObserver( this );

   211 

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

   213     iBurstModeObservers.Close();

   214 

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

   216         {

   217         iWaitTimer->Cancel();

   218         }

   219     delete iWaitTimer;

   220     delete iDocHandler;

   221     delete iCamSidePane;

   222     delete iCamZoomPane;       

   223 

   224     delete iRepository;

   225 

   226 /*#ifndef __WINSCW__

   227     delete iSFIUtils;

   228 #endif*/

   229 

   230     delete iNaviCounterControl;

   231     delete iNaviProgressBarControl;

   232     delete iNaviCounterModel;

   233     delete iNaviProgressBarModel;  

   234     delete iActivePaletteHandler;

   235     iActivePaletteHandler = NULL;

   236 

   237     if( iCourtesyTimer )

   238         {

   239         iCourtesyTimer->Cancel();

   240         }

   241     delete iCourtesyTimer;

   242     delete iScreenClearer;

   243     delete iVolumeKeyObserver;

   244 

   245     delete iCollectionManager;

   246     iCollectionManager = NULL;

   247 

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

   249     }

   250 

   251 // -----------------------------------------------------------------------------

   252 // CCamAppUi::ConstructL

   253 // Symbian 2nd phase constructor can leave.

   254 // -----------------------------------------------------------------------------

   255 //

   256 void CCamAppUi::ConstructL()

   257   {

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

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

   260   iRotatedKeyEvent = ETrue;

   261   iReturnedFromPlugin = EFalse;

   262   iController.SetAppUiAvailable( ETrue );

   263 

   264   iLockedQwertyState = E2ndCamUnknown; 

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

   266 

   267   TInt memError =

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

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

   270                                           ETrue );

   271 

   272 

   273   TInt freeMemory = 0;

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

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

   276       {

   277       User::Leave( memError );

   278       }

   279   iUiConstructionComplete = EFalse;

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

   281   

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

   283   

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

   285   RArray<TInt> screenModeValues;

   286   if ( uiOrientationOverride )

   287       {

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

   289       iLandscapeScreenMode = screenModeValues[0];

   290       iPortraitScreenMode = screenModeValues[1];

   291       }

   292   

   293   // The embedded views are set after ConstructL completes

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

   295   iEmbeddedViewSet = !IsEmbedded();

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

   297   

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

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

   300   iRequestedNewFileResolution.SetSize( 0, 0 );

   301 

   302   // Camera window group id

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

   304 

   305   // Get the id of Eikon Server window group

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

   307     0,

   308     KEikonServer );

   309   

   310   CApaWindowGroupName::FindByAppUid(

   311     KBtNotifierServerUid,

   312     iCoeEnv->WsSession(),

   313     iBTServerWindowGroupId);

   314 

   315   CApaWindowGroupName::FindByAppUid(

   316     KPhoneAppUid,

   317     iCoeEnv->WsSession(),

   318     iPhoneAppWindowGroupId);

   319 

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

   321   TInt crValue = 0;

   322   if( !iRepository )

   323     {

   324     iRepository = CRepository::NewL( KCRUidCameraappSettings ); 

   325     }

   326 

   327   // get softkey position

   328   CamUtility::GetPsiInt( ECamPsiSoftKeyPosition, iSoftkeyPosition );

   329   

   330   iCamOrientation = ReadCurrentDeviceOrientation();

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

   332   PERF_EVENT_START_L2( EPerfEventAvkonUIConstruction );  

   333   TInt orientation;

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

   335       {

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

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

   338       TInt sliderPosition;

   339       TInt err = RProperty::Get(

   340             CameraPlatPSKeys::KPSCameraPlatUid,

   341             CameraPlatPSKeys::KLensCoverStatus,

   342             sliderPosition );  

   343       

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

   345       if( err == KErrNotFound )

   346           {

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

   348           err = RProperty::Get(

   349               NMusResourceApi::KCategoryUid,

   350               NMusResourceApi::KCameraAvailability,

   351               sliderPosition );  

   352           }

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

   354             sliderPosition, err );

   355   

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

   357       // more than one camera) 

   358       if ( err )

   359         {

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

   361         iController.SetCameraSwitchRequired( ESwitchToUnknown );

   362         }

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

   364              sliderPosition == CameraPlatPSKeys::EClosed ) || 

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

   366           {

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

   368           CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, orientation );

   369           }

   370       else

   371           {

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

   373           CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, orientation );    

   374           } 

   375       }

   376   else

   377       {

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

   379       CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, orientation );

   380       }

   381 

   382   // Finish engine construction    

   383   if( uiOrientationOverride )

   384     {

   385     iController.CompleteConstructionL();

   386     }

   387 

   388   if ( orientation == ( TInt ) EAppUiOrientationLandscape )

   389     {

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

   391     iCamOrientation = (ECamHandLeft == iSoftkeyPosition ) 

   392                     ? ECamOrientationCamcorderLeft 

   393                     : ECamOrientationCamcorder;

   394     if( uiOrientationOverride )

   395       {

   396       //set orientation to CCamera	

   397       iController.SetCameraOrientationModeL( iLandscapeScreenMode );

   398       // and complete the cameracontroller construction

   399       iController.CompleteCameraConstructionL();

   400       }

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

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

   403     BaseConstructL( EAppOrientationLandscape | EAknEnableSkin | EAknEnableMSK | 

   404                     ENonStandardResourceFile | EAknSingleClickCompatible );

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

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

   407     }

   408   else

   409     {

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

   411     iCamOrientation = ECamOrientationPortrait;

   412     if( uiOrientationOverride )

   413       {

   414       //set orientation to CCamera	

   415       iController.SetCameraOrientationModeL( iPortraitScreenMode );

   416       // and complete the cameracontroller construction

   417       iController.CompleteCameraConstructionL();

   418       }     

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

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

   421     BaseConstructL( EAppOrientationPortrait | EAknEnableSkin | EAknEnableMSK | 

   422                     ENonStandardResourceFile );  

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

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

   425     }

   426 

   427     PERF_EVENT_END_L2( EPerfEventAvkonUIConstruction );

   428 

   429 #if !defined (__WINSCW__)

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

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

   432   // application.

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

   434      {

   435       RegisterCaptureKeysL();

   436      }

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

   438 #endif

   439 

   440   if( !uiOrientationOverride )

   441     {

   442     // Load the settings model static settings

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

   444     iController.LoadStaticSettingsL( IsEmbedded() );

   445   

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

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

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

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

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

   451     TBool expectLandscape = (iCamOrientation != ECamOrientationPortrait);

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

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

   454       {

   455       iEngineConstructionDelayed = ETrue;

   456       }

   457 

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

   459 

   460     // initialise the self timer mode 

   461     iInSelfTimerMode = ECamSelfTimerDisabled;

   462 

   463     if ( !iEngineConstructionDelayed )     

   464       {

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

   466       iController.CompleteConstructionL();

   467       iController.StoreUserSceneSettingsL();

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

   469 

   470       } 

   471     }

   472   else

   473     {

   474     iEngineConstructionDelayed = EFalse;    

   475     iInSelfTimerMode = ECamSelfTimerDisabled;

   476     }

   477   

   478   

   479   iEmbeddedObserver = NULL;

   480   

   481   iController.AddControllerObserverL( this );

   482   iController.AddCameraObserverL( this, KCameraEventInterest );

   483   

   484   if( !uiOrientationOverride )

   485     {

   486 /*#ifndef __WINSCW__

   487     // Initialize SFIUtils

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

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

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

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

   492 	User::LeaveIfError(errSFI);

   493     iSendFileInCall = EFalse;

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

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

   496 #endif*/

   497 

   498     // Create text resolver for error note text

   499     iTextResolver = CTextResolver::NewL();

   500 

   501     ConstructPreCaptureViewsL();

   502   

   503     iSelfTimer = CCamSelfTimer::NewL( iController );

   504 #if defined( CAMERAAPP_CAPI_V2_DVF )

   505     iSelfTimer->AddObserverL( this ); 

   506 #endif // CAMERAAPP_CAPI_V2_DVF

   507 

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

   509     iNaviCounterModel = CCamNaviCounterModel::NewL( iController );

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

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

   512   

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

   514     iNaviProgressBarModel = CCamNaviProgressBarModel::NewL( iController );

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

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

   517   

   518     ConstructNaviPaneL();

   519     }

   520 

   521   

   522   iRepository->Get( KCamCrAlwaysDrawCourtesyUi, crValue );

   523   iAlwaysDrawPreCaptureCourtesyUI = (crValue == KCamCrAlwaysDrawCourtesyUiIsOn);

   524 

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

   526 

   527 

   528   if( uiOrientationOverride )

   529     {

   530     // always start in still mode	

   531     iMode = ECamControllerImage;

   532     iTargetMode = ECamControllerImage;	

   533     }

   534   else

   535     {  

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

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

   538     // state will be standby    

   539     if ( !IsConstructionComplete() )

   540       {

   541       iViewState = ECamViewStateStandby;

   542       }

   543 

   544     // Get start up mode from settings.

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

   546     // when HandleNewFileL is called by the framework

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

   548     if ( StartupMode() == ECamStillCapture )

   549       {

   550       iMode = ECamControllerImage;

   551       iTargetMode = ECamControllerImage;

   552       SetDefaultViewL( *iStillCaptureView );

   553       }

   554     else

   555       {

   556       iMode = ECamControllerVideo;

   557       iTargetMode = ECamControllerVideo;

   558       SetDefaultViewL( *iVideoCaptureView );

   559       }      

   560 

   561 

   562     if( !iEngineConstructionDelayed )

   563       {

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

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

   566       TBool overlayViewFinder;

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

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

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

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

   571     

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

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

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

   575       }

   576   }  

   577   // create the timer used for callbacks

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

   579 

   580  

   581   // initialise the view construction states

   582   iPostCaptureViewsConstructed     = EFalse;

   583   iUserSceneSetupViewConstructed   = EFalse;

   584   iCustomiseToolbarViewConstructed = EFalse;

   585   

   586   if( !uiOrientationOverride )

   587     {  

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

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

   590   iController.CheckMemoryToUseL();

   591   

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

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

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

   595     iNaviCounterControl->SetExtentToWholeScreen();

   596   

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

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

   599   

   600     // get max num of images for burst capture

   601     CamUtility::GetPsiInt( ECamPsiMaxBurstCapture, iMaxBurstCaptureNum );

   602   

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

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

   605     }

   606       

   607   iDrawPreCaptureCourtesyUI = ETrue;

   608   iDrawPostCaptureCourtesyUI = ETrue;

   609   iAlwaysDrawPostCaptureCourtesyUI = ETrue;

   610   iLeftSoftKeyPressed = EFalse;

   611   if( !uiOrientationOverride )

   612     {

   613     // get coutesy UI timeout

   614     TInt timeoutValue;

   615     CamUtility::GetPsiInt( ECamPsiCourtesyUiTimeoutValue, timeoutValue );

   616   

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

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

   619 

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

   621     UpdateNaviModelsL();

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

   623     iNaviCounterModel->ReloadResourceDataL();

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

   625     iNaviProgressBarModel->ReloadResourceDataL();

   626     }

   627       

   628   iZoomPaneShown = EFalse;

   629   iFirstBoot = ETrue; // Show zoom

   630   iProcessingScreenRedraw = EFalse;

   631   iSendAsInProgress = EFalse;

   632   

   633   if( !uiOrientationOverride )

   634     {  

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

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

   637     }

   638 

   639   iCheckOperationInProgress = EFalse;

   640   iLostFocusToNewWindow = EFalse;

   641   iFirstVFStart = ETrue;

   642 

   643   iInternalStorage = iController.ExistMassStorage()?ECamMediaStorageMassStorage:ECamMediaStoragePhone;

   644 

   645   if ( !uiOrientationOverride )

   646     {

   647     iUiConstructionComplete = ETrue;

   648     }

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

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

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

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

   653   }

   654     

   655 

   656 

   657 // -----------------------------------------------------------------------------

   658 // IsInternalView

   659 // -----------------------------------------------------------------------------

   660 //

   661 TBool CCamAppUi::IsInternalView( TCamViewState aViewState ) const

   662   {

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

   664 

   665   TBool internal( EFalse );

   666 

   667   if ( aViewState < ECamViewStateRangeInternalMax

   668     && aViewState > ECamViewStateRangeInternalMin )

   669       {

   670       internal = ETrue;

   671       }

   672   else if( aViewState < ECamViewStateRangeExternalMax

   673         && aViewState > ECamViewStateRangeExternalMin )

   674       {

   675       internal = EFalse;

   676       }

   677   else

   678     {

   679     CamPanic( ECamPanicInvalidView );

   680     }

   681 

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

   683   return internal;

   684   }

   685 

   686 

   687  

   688 // -----------------------------------------------------------------------------

   689 // CCamAppUi::IsConstructionComplete

   690 // Returns whether or not all construction has completed

   691 // -----------------------------------------------------------------------------

   692 //    

   693 TBool CCamAppUi::IsConstructionComplete() const

   694     {     

   695     TBool complete = ETrue;

   696     complete = !iEngineConstructionDelayed;

   697     return complete && iEmbeddedViewSet; 

   698     }

   699 

   700     

   701 // -----------------------------------------------------------------------------

   702 // CCamAppUi::NaviCounter

   703 // Returns the pointer to the NaviCounter control

   704 // -----------------------------------------------------------------------------

   705 //

   706 CCamNaviCounterControl* CCamAppUi::NaviCounterControl()

   707     {

   708     return iNaviCounterControl;

   709     }

   710     

   711 // -----------------------------------------------------------------------------

   712 // CCamAppUi::NaviProgressBar

   713 // Returns the pointer to the NaviProgress control

   714 // -----------------------------------------------------------------------------

   715 //

   716 CCamNaviProgressBarControl* CCamAppUi::NaviProgressBarControl()

   717     {

   718     return iNaviProgressBarControl;

   719     }

   720 

   721 // -----------------------------------------------------------------------------

   722 // CCamAppUi::NaviCounterModel

   723 // Returns the pointer to the NaviCounter model

   724 // -----------------------------------------------------------------------------

   725 //    

   726 CCamNaviCounterModel* CCamAppUi::NaviCounterModel()

   727     {

   728     return iNaviCounterModel;

   729     }

   730 

   731 

   732 // -----------------------------------------------------------------------------

   733 // CCamAppUi::CCamAppUi

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

   735 // might leave.

   736 // -----------------------------------------------------------------------------

   737 //

   738 CCamAppUi::CCamAppUi( CCamAppController& aController )                              

   739     : iController( aController ),

   740     iViewState( ECamViewStatePreCapture ),

   741     iTargetViewState( ECamViewStatePreCapture ), 

   742     iPreventActivePaletteDisplay( EFalse ),

   743     iInternalStorage(ECamMediaStorageNone)

   744     {

   745     }

   746 

   747 // ----------------------------------------------------

   748 // CCamAppUi::SetTitleL

   749 // Set title pane text from a resource.

   750 // ----------------------------------------------------

   751 //

   752 void CCamAppUi::SetTitleL( TInt aResourceId )

   753     {

   754     // Set title

   755     CAknTitlePane* title = static_cast<CAknTitlePane*>(

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

   757     TResourceReader reader;

   758     iCoeEnv->CreateResourceReaderLC( reader, aResourceId );

   759     title->SetFromResourceL( reader );

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

   761     }

   762 

   763 // ----------------------------------------------------

   764 // CCamAppUi::SetTitleL

   765 // Set title pane text from a descriptor.

   766 // ----------------------------------------------------

   767 //

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

   769     {

   770     CAknTitlePane* title = static_cast<CAknTitlePane*>(

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

   772     title->SetTextL( aText );

   773     }

   774 

   775 

   776 

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

   778 // CCamAppUi::PushNaviPaneCounterL

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

   780 // ----------------------------------------------------

   781 //

   782 void 

   783 CCamAppUi::PushNaviPaneCounterL()

   784   {

   785   iNaviCounterModel->SetCaptureModeL( iMode, iImageMode );

   786   iDecoratedNaviPaneCounter->MakeScrollButtonVisible( EFalse );

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

   788   }

   789 

   790 // ----------------------------------------------------

   791 // CCamAppUi::PushNaviPaneProgressBarL

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

   793 // ----------------------------------------------------

   794 //

   795 void CCamAppUi::PushNaviPaneProgressBarL()

   796     {

   797     iDecoratedNaviPaneProgressBar->MakeScrollButtonVisible( EFalse );

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

   799     }

   800 

   801 // ----------------------------------------------------

   802 // CCamAppUi::PushDefaultNaviPaneL

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

   804 // ----------------------------------------------------

   805 //

   806 void CCamAppUi::PushDefaultNaviPaneL()

   807     {

   808     NaviPaneL()->PushDefaultL();

   809     }

   810 

   811 

   812 // ----------------------------------------------------

   813 // CCamAppUi::DisplayDeleteNoteL

   814 // Call DisplayDeleteNoteL on the current view

   815 // ----------------------------------------------------

   816 //

   817 TBool CCamAppUi::DisplayDeleteNoteL()

   818   {

   819   TBool deleted = 

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

   821 

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

   823   if ( deleted )

   824     {

   825                               

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

   827         {

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

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

   830         // opened/closed after starting the capture

   831         iController.CheckSlideStatus();

   832         }      

   833                                

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

   835     // return to thumbnail view

   836     if ( ECamImageCaptureBurst == iController.CurrentImageModeSetup()

   837       && 0                     <  iController.CurrentItemCount() )

   838       {

   839       iTargetViewState = ECamViewStateBurstThumbnail;

   840       }

   841     // otherwise switch to pre-capture view

   842     else

   843       {

   844       iTargetViewState = ECamViewStatePreCapture;

   845       }

   846     TrySwitchViewL();

   847     }

   848   else

   849     {

   850     }

   851   return deleted;

   852   }

   853 

   854 // ----------------------------------------------------

   855 // CCamAppUi::SelfTimerEnableL

   856 // Enable or disable SelfTimer functionality

   857 // ----------------------------------------------------

   858 //

   859 void CCamAppUi::SelfTimerEnableL( TCamSelfTimerFunctions aState )

   860     {

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

   862     if ( iInSelfTimerMode == aState )

   863         {

   864         return;

   865         }

   866 

   867     __ASSERT_DEBUG( iSelfTimer, CamPanic( ECamPanicNullPointer ) );

   868 

   869     // Update the member variable

   870     iInSelfTimerMode = aState;

   871 

   872     if ( aState != ECamSelfTimerDisabled  )

   873         {     

   874         // Set up for current timer mode

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

   876         UpdateCba();

   877         }

   878     else                

   879         {

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

   881         iSelfTimer->Cancel();

   882 

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

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

   885         // when setting the self timer mode above

   886         if( iPreCaptureMode != ECamPreCapCaptureSetup )

   887             {

   888             // Re-show the active palette

   889             iActivePaletteHandler->UpdateActivePaletteL();

   890             iPreventActivePaletteDisplay = EFalse;

   891             SetActivePaletteVisibility( ETrue );

   892             

   893             if ( iController.IsTouchScreenSupported() )

   894                 {

   895                 CAknToolbar* toolbar = CurrentFixedToolbar();

   896                 if (toolbar)

   897                     {

   898                     toolbar->SetToolbarVisibility( ETrue );

   899                     }

   900                 }

   901             // Cancel any active focusing operation

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

   903             iController.CancelFocusAndCapture();

   904                 

   905             iStillCaptureView->UpdateToolbarIconsL();

   906             

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

   908             // if hide icons is enabled.

   909             RaisePreCaptureCourtesyUI(EFalse);        

   910             }        

   911         

   912         UpdateCba();

   913         }    

   914     }

   915 

   916 // -----------------------------------------------------------------------------

   917 // CCamAppUi::SelfTimerEnabled

   918 // Returns current self-timer state

   919 // -----------------------------------------------------------------------------

   920 //        

   921 TBool CCamAppUi::SelfTimerEnabled() const

   922     {

   923     return ( iInSelfTimerMode != ECamSelfTimerDisabled );

   924     }

   925 

   926 // -----------------------------------------------------------------------------

   927 // CCamAppUi::SelfTimer

   928 // Returns pointer to self-timer object

   929 // -----------------------------------------------------------------------------

   930 //        

   931 CCamSelfTimer* CCamAppUi::SelfTimer()

   932     {

   933     return iSelfTimer;

   934     }

   935 

   936 // -----------------------------------------------------------------------------

   937 // CCamAppUi::AddBurstModeObserverL

   938 // Register an observer for burst mode changes

   939 // -----------------------------------------------------------------------------

   940 // 

   941 void 

   942 CCamAppUi::AddBurstModeObserverL( MCamBurstModeObserver* aBurstModeObserver )

   943   {

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

   945   if( aBurstModeObserver &&

   946      KErrNotFound == iBurstModeObservers.Find( aBurstModeObserver ) )

   947     {

   948     iBurstModeObservers.AppendL( aBurstModeObserver );

   949     }

   950   }

   951 

   952 // -----------------------------------------------------------------------------

   953 // CCamAppUi::RemoveBurstModeObserver

   954 // Remove the burst mode observer

   955 // -----------------------------------------------------------------------------

   956 //

   957 void

   958 CCamAppUi::RemoveBurstModeObserver( const MCamBurstModeObserver* aBurstModeObserver )

   959   {

   960   if( aBurstModeObserver )

   961     {

   962     TInt index = iBurstModeObservers.Find( aBurstModeObserver );

   963     if( KErrNotFound != index )

   964       {

   965       iBurstModeObservers.Remove( index );

   966       }

   967     }

   968   }

   969 

   970 // -----------------------------------------------------------------------------

   971 // CCamAppUi::IsBurstEnabled

   972 // Return burst mode enabled state

   973 // -----------------------------------------------------------------------------

   974 //

   975 TBool CCamAppUi::IsBurstEnabled() const

   976   {

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

   978   TBool ret = EFalse;

   979   if ( ECamImageCaptureBurst     == iImageMode 

   980     || ECamImageCaptureTimeLapse == iImageMode )

   981     {

   982     ret = ETrue;

   983     }

   984 

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

   986   return ret;

   987   }

   988     

   989 // -----------------------------------------------------------------------------

   990 // CCamAppUi::CurrentBurstMode

   991 // Return burst mode enabled type

   992 // -----------------------------------------------------------------------------

   993 // 

   994 TCamImageCaptureMode CCamAppUi::CurrentBurstMode() const

   995   {

   996   PRINT_FRQ( _L("Camera => CCamAppUi::CurrentBurstMode" ) )

   997   TCamImageCaptureMode mode( ECamImageCaptureNone );

   998 

   999   if ( ECamImageCaptureBurst     == iImageMode

  1000     || ECamImageCaptureTimeLapse == iImageMode )

  1001     {

  1002     mode = iImageMode;

  1003     }

  1004 

  1005   PRINT_FRQ( _L("Camera <= CCamAppUi::CurrentBurstMode" ) )

  1006   return mode;

  1007   }   

  1008 

  1009 

  1010 // -----------------------------------------------------------------------------

  1011 // CCamAppUi::IsSecondCameraEnabled

  1012 // Returns whether or the secondary camera has been activated

  1013 // Will return ETrue when when the second camera is active

  1014 // -----------------------------------------------------------------------------

  1015 //

  1016 TBool CCamAppUi::IsSecondCameraEnabled() const

  1017     {

  1018     PRINT_FRQ( _L("Camera =><= CCamAppUi::IsSecondCameraEnabled" ))

  1019     return iController.ActiveCamera() == ECamActiveCameraSecondary;

  1020     }

  1021 

  1022 // -----------------------------------------------------------------------------

  1023 // CCamAppUi::IsQwerty2ndCamera

  1024 // -----------------------------------------------------------------------------

  1025 //

  1026 TBool CCamAppUi::IsQwerty2ndCamera( TBool aLock )

  1027     {

  1028     TBool ret = EFalse;

  1029     if ( aLock )

  1030         {

  1031         iLockedQwertyState = E2ndCamUnknown;

  1032         }

  1033 

  1034     switch( iLockedQwertyState )

  1035         {

  1036         case E2ndCamPortraitForced: 

  1037             {

  1038             ret = EFalse; 

  1039             break;

  1040             }

  1041         case E2ndCamLandscapeForced:     

  1042             {

  1043             ret = ETrue; 

  1044             break;

  1045             }

  1046         case E2ndCamUnknown:     

  1047             {

  1048             // Get variant setting i.e. initialize

  1049             TInt value = 0;

  1050             if ( iController.UiConfigManagerPtr() )

  1051                {

  1052             	value = iController.UiConfigManagerPtr()->IsQwerty2ndCamera();

  1053                 

  1054                 iLockedQwertyState = static_cast<T2ndCamOrientation>(value); 

  1055                 if ( iLockedQwertyState == E2ndCamAuto )

  1056                     {

  1057                     ret = CamUtility::IsQwertyOpen(); 

  1058                     }

  1059                 else

  1060                     {

  1061                     ret = iLockedQwertyState == E2ndCamLandscapeForced;

  1062                     }

  1063  		}            

  1064             break;

  1065             }

  1066         case E2ndCamAuto:

  1067             {

  1068             ret = CamUtility::IsQwertyOpen(); 

  1069             break;

  1070             }

  1071         default: 

  1072             break;

  1073         }

  1074 

  1075     if ( aLock )

  1076         {

  1077         iLockedQwertyState = ret?E2ndCamLandscapeForced:E2ndCamPortraitForced;

  1078         }

  1079 

  1080     return ret;

  1081     }

  1082 

  1083 // -----------------------------------------------------------------------------

  1084 // CCamAppUi::IsWaitDialog

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

  1086 //

  1087 TBool CCamAppUi::IsWaitDialog() const

  1088   {

  1089   return iWaitDialog != NULL;

  1090   }

  1091 

  1092 // -----------------------------------------------------------------------------

  1093 // CCamAppUi::ActiveCamera

  1094 // Returns the active camera

  1095 // -----------------------------------------------------------------------------

  1096 //

  1097 TCamActiveCamera CCamAppUi::ActiveCamera() const

  1098   {

  1099   return iController.ActiveCamera();

  1100   }

  1101     

  1102 // -----------------------------------------------------------------------------

  1103 // CCamAppUi::HandleCommandL

  1104 // Handle user menu selections

  1105 // -----------------------------------------------------------------------------

  1106 //

  1107 void CCamAppUi::HandleCommandL( TInt aCommand )

  1108   {

  1109   PRINT1( _L("Camera => CCamAppUi::HandleCommandL (%d)"), aCommand )

  1110   switch( aCommand )

  1111     {       

  1112     // -----------------------------------------------------

  1113     case ECamCmdRaiseCourtesyUI:

  1114       {            

  1115       if ( ECamViewStatePreCapture == iViewState )

  1116         {

  1117         RaisePreCaptureCourtesyUI(EFalse);

  1118         }

  1119       else if ( ECamViewStatePostCapture == iViewState )

  1120         {

  1121         // iLeftSoftKeyPressed resembles the Left SoftKey(LSK) 

  1122         // press when AP tool bar is hidden

  1123 

  1124         if ( iLeftSoftKeyPressed )

  1125         	{

  1126         	// LSK is pressed, we raise the AP tool bar

  1127         	RaisePostCaptureCourtesyUI();

  1128         	}

  1129         else

  1130         	{

  1131         	// RSK is pressed, we return back to PreCaptureView

  1132         	HandleCommandL( EAknSoftkeyBack );	

  1133         	}

  1134