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:  Base class for pre capture views*

    15 */

    16 

    17 

    18 // INCLUDE FILES

    19 #include <eikbtgpc.h>

    20 #include <eikmenub.h>

    21 #include <musresourceproperties.h>

    22 #include <cameraplatpskeys.h>

    23 #include <cameraapp.rsg>

    24 #include <vgacamsettings.rsg>

    25 #include <akntoolbar.h>

    26 #include <akntoolbarextension.h>

    27 #include <aknbutton.h>

    28 #include <eiksoftkeypostingtransparency.h>

    29 #include <AknsUtils.h>

    30 #include <gulicon.h>

    31 

    32 #include "Cam.hrh"

    33 #include "CamAppUi.h"

    34 #include "CamUtility.h"

    35 #include "CamAppController.h"

    36 #include "CamPreCaptureContainerBase.h"

    37 #include "CamLogger.h"

    38 #include "CamPanic.h"

    39 #include "CamCaptureSetupMenu.h"

    40 #include "CamStandbyContainer.h"

    41 #include "CamSelfTimer.h"

    42 #include "CamTimer.h"

    43 #include "camactivepalettehandler.h"

    44 #include "CamPreCaptureViewBase.h"

    45 #include "CameraUiConfigManager.h"

    46 #include "OstTraceDefinitions.h"

    47 #ifdef OST_TRACE_COMPILER_IN_USE

    48 #include "CamPreCaptureViewBaseTraces.h"

    49 #endif

    50 

    51 #include "camstartuplogocontroller.h" 

    52 

    53 // ===========================================================================

    54 // Constants

    55 

    56 

    57 

    58 // ========================= MEMBER FUNCTIONS ================================

    59 

    60 // ---------------------------------------------------------------------------

    61 // CCamPreCaptureViewBase destructor

    62 // 

    63 // ---------------------------------------------------------------------------

    64 //

    65 CCamPreCaptureViewBase::~CCamPreCaptureViewBase()

    66   {

    67   PRINT( _L("Camera => ~CCamPreCaptureViewBase") );

    68   if ( iGestureFw ) 

    69       {

    70       delete iGestureFw;

    71       }

    72   PRINT( _L("Camera <= ~CCamPreCaptureViewBase") );

    73   }

    74 

    75 // -----------------------------------------------------------------------------

    76 // CCamPreCaptureViewBase::HandleCommandL

    77 // Handle commands

    78 // -----------------------------------------------------------------------------

    79 //

    80 void CCamPreCaptureViewBase::HandleCommandL( TInt aCommand )

    81     {

    82     PRINT( _L("Camera => CCamPreCaptureViewBase::HandleCommandL") );

    83 

    84     iLastMovement = 0;

    85     switch ( aCommand )

    86         {              

    87         case ECamCmdShootSetup:

    88             {

    89             CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );

    90             TBool selfTimerEnabled = appUi->SelfTimerEnabled();

    91 

    92             if ( selfTimerEnabled )

    93                 {                

    94                 CCamSelfTimer* selftimer = appUi->SelfTimer();

    95 

    96                 // If self-timer is enabled, we need to check that it is in

    97                 // self-timer standby, ie Enabled but not Active (ie not 

    98                 // counting down)

    99                 if ( selftimer && !selftimer->IsActive() )

   100                     {

   101                     // In self-timer standby, pressing "select" button starts 

   102                     // self-timer count down.  Pass this event on to AppUi.

   103                     appUi->HandleCommandL( ECamCmdSelfTimerActivate );

   104                     }

   105                 }

   106             else 

   107                 {

   108                 // we are not in self -timer mode and check we are

   109                 // not already in capture setup mode

   110                 if ( !iCaptureSetupMenuModeActive )

   111                     {

   112                     // Ensure first item is selected in CSM.

   113                     iCaptureSetupMenuLastItemIndex = 0;

   114                     SwitchToCaptureSetupMenuModeL();

   115                     }

   116                     

   117                 }            

   118             }

   119             break;

   120 

   121         // If an item in the capture setup menu has been selected.

   122         case EAknSoftkeySelect:  

   123             {

   124             if ( ActiveSettingMode() == ECamSettingModeCaptureMenu )

   125                 {

   126                 iCaptureSetupMenuContainer->HandleCommandL( aCommand );

   127                 }

   128             else

   129                 {          

   130                 CCamCaptureSetupViewBase::HandleCommandL( aCommand );             

   131                 }

   132             }

   133             break;

   134             

   135         // If capture setup menu is active and user presses softkey back,

   136         //  deactivate the menu. This is EEikBidCancel which has the same

   137         //  enumeration value as EAknSoftkeyCancel.

   138         case EAknSoftkeyCancel:

   139             {            

   140             if ( ActiveSettingMode() == ECamSettingModeCaptureMenu )

   141                 {

   142                 ExitCaptureSetupMenuModeL();

   143                 }

   144             else if ( iController.SequenceCaptureInProgress() )                         

   145                 // Check if currently capturing a burst, if so, cancel it

   146                 {

   147                 // If already received all the snapshots

   148                 if ( iController.AllSnapshotsReceived() ) 

   149                     {

   150                     // stop burst immediately

   151                     iController.StopSequenceCaptureL();

   152                     }

   153                 else

   154                     {

   155                     // capture the min images (2), before stopping the burst

   156                     iController.SetKeyUp( ETrue );

   157                     iController.SoftStopBurstL( ETrue );

   158                     }

   159                 // Update CBA for setup pane usage

   160                 SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); 

   161                 }     

   162             else

   163                 {

   164                 CCamCaptureSetupViewBase::HandleCommandL( aCommand );                                                                                       

   165                 }                        

   166             }

   167             break;

   168         case EAknSoftkeyOptions:

   169             {

   170             // do nothing, the command is handled by the framework

   171             }

   172             break;

   173             

   174         // Note: CaptureSetupMenu mode also uses a 'Back' softkey but this has

   175         // the command value EEikBidCancel            

   176         case EAknSoftkeyBack:

   177             {                                          

   178             // exit to embedded app if we're embedded and in plain pre-capture

   179             if ( iEmbedded 

   180                 && ActiveSettingMode() != ECamSettingModeScene 

   181                 && ActiveSettingMode() != ECamSettingModeInfoListBox )

   182                 {

   183                 CCamCaptureSetupViewBase::HandleCommandL( ECamCmdInternalExit );

   184                 }

   185             else

   186                 {

   187                 CCamCaptureSetupViewBase::HandleCommandL( aCommand );              

   188                 }                           

   189                

   190             }

   191             break;

   192             

   193         case EAknSoftkeyOk:

   194             {                                                                

   195                 // Else pass on to lower levels

   196                 CCamCaptureSetupViewBase::HandleCommandL( aCommand );                                     

   197             }

   198             break;

   199             

   200         case ECamCmdToggleCourtesyUI:

   201             {

   202             CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   203             

   204             if ( appUi )

   205                 {

   206                 appUi->SetAlwaysDrawPreCaptureCourtesyUI( !appUi->AlwaysDrawPreCaptureCourtesyUI() );

   207                 }

   208             }

   209             break;

   210        case ECamCmdPopUpMenuZoom: 

   211             {

   212             if ( iContainer )

   213                 {

   214                 iContainer->ShowZoomPaneWithTimer();

   215                 }

   216             }     

   217             break;

   218         case ECamCmdCaptureSetupFlashStill:

   219             {

   220             iToolbarExtensionInvisible = ETrue;

   221            	CCamCaptureSetupViewBase::HandleCommandL( aCommand );

   222             }     

   223             break;

   224         case ECamCmdInternalExit:

   225             {

   226             const TCamCaptureOperation operation( 

   227                     iController.CurrentOperation() );

   228             

   229                  if ( ECamPaused == operation )

   230                    {

   231                    iController.StopVideoRecording();

   232                    iController.SetCaptureKeyPressedWhileImageSaving( ETrue );

   233                    }

   234             StopViewFinder();

   235             CCamCaptureSetupViewBase::HandleCommandL( aCommand );

   236             if ( iController.IsTouchScreenSupported() )

   237                 {

   238                 CAknToolbar* fixedToolbar = Toolbar();

   239                 if ( fixedToolbar )

   240                     {

   241                     CAknToolbarExtension* extension = 

   242                         fixedToolbar->ToolbarExtension();

   243                     if ( extension )

   244                         {

   245                         // Reset toolbar extension button and view to closed state

   246                         extension->SetShown( EFalse );

   247                         extension->SetCurrentState( 0, EFalse );

   248                         }

   249                     }

   250                 }

   251             }     

   252             break;

   253         case ECamCmdSettings:

   254             // Hide the capture button

   255             if ( iContainer )

   256                 {

   257                 iContainer->SetFocus( EFalse );

   258                 }

   259             // fall-through

   260         default:

   261             {                                       

   262             CCamCaptureSetupViewBase::HandleCommandL( aCommand );                            

   263             }

   264         }

   265     PRINT( _L("Camera <= CCamPreCaptureViewBase::HandleCommandL") );

   266     }

   267 

   268 // -----------------------------------------------------------------------------

   269 // CCamPreCaptureViewBase::HandleForegroundEventL

   270 // Handle a move to the foreground

   271 // -----------------------------------------------------------------------------

   272 //

   273 void CCamPreCaptureViewBase::HandleForegroundEventL( TBool aForeground )

   274   {

   275   PRINT1( _L( "Camera => CCamPreCaptureViewBase::HandleForegroundEventL %d" ), aForeground );    

   276 

   277   iLastMovement = 0;

   278   CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );                

   279   __ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));

   280 

   281   // -----------------------------------------------------

   282   // coming to the foreground

   283   if ( aForeground )

   284     {

   285     // Ignore foregrounding if view switch to postcapture anyway in progress.

   286     if( appUi->TargetViewState() == ECamViewStatePostCapture

   287      || appUi->TargetViewState() == ECamViewStateBurstThumbnail 

   288      || ( iStandbyModeActive && !appUi->IsRecoverableStatus() ) ) {

   289       PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL, ignored states") );    

   290       return;

   291     }

   292     

   293     

   294     if ( !( iController.UiConfigManagerPtr() && 

   295             iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )

   296         {

   297         if ( !iController.IsTouchScreenSupported() )

   298             {

   299             if ( !appUi->ActivePalette() )

   300                 {

   301                 SetupActivePaletteL();

   302                 }

   303             else

   304                 {

   305                 appUi->APHandler()->UpdateActivePaletteL();

   306                 }

   307             }

   308         }

   309     UpdateCbaL();

   310     

   311     // restart idle timer in any case

   312      iController.StartIdleTimer();

   313                                  

   314     // If capture setup menu is active then ensure background is faded.

   315     if ( iCaptureSetupMenuContainer )

   316       {

   317       iCaptureSetupMenuContainer->FadeBehind( ETrue );

   318       }       

   319 

   320     // coming to the foreground from an eikon server window

   321     if ( iContinueInBackground )

   322       {

   323       iContinueInBackground = EFalse;

   324 

   325       if ( !iController.IsViewFinding()  && !iSceneSettingModeActive )

   326         {

   327       	iController.StartViewFinder();

   328         }

   329       else if( iLocationTrailConnecting )

   330           {

   331           iLocationTrailConnecting = EFalse;

   332           iController.StopViewFinder();

   333           iController.StartViewFinder();

   334           }

   335       CCamCaptureSetupViewBase::HandleForegroundEventL( aForeground );

   336 

   337       UpdateCbaL();

   338       if ( iController.CameraSwitchQueued() )

   339           {

   340           appUi->HandleCommandL( ECamCmdSwitchCamera );

   341           }

   342       PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL - continuing in background" ) );            

   343       return;

   344       }

   345     

   346     // This only happens when the app is first launched        

   347     if ( !appUi->IsConstructionComplete() && 

   348          !iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported())    

   349       {

   350       iActivateToStandby = ETrue;

   351       if ( !iStandbyModeActive )

   352         {

   353         //iStandbyError = KErrNone;

   354         appUi->SetStandbyStatus( KErrNone );        

   355         PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: sending ECamCmdGoToStandby" ) );    

   356         HandleCommandL( ECamCmdGoToStandby );

   357         SetTitlePaneTextL();

   358         }            

   359       }

   360 

   361     // Register that we want to use the engine

   362     IncrementCameraUsers();

   363     

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

   365         {

   366         if ( iController.CameraSwitchQueued() )

   367             {

   368             appUi->HandleCommandL( ECamCmdSwitchCamera );

   369             }

   370         else if ( appUi->TargetViewState() != ECamViewStatePostCapture )      

   371             {   

   372             TCamCameraMode mode = iController.CurrentMode(); 

   373             if ( mode == ECamControllerVideo )

   374                 {

   375                 iController.EnterViewfinderMode( ECamControllerVideo );

   376                 }       

   377             else if( mode == ECamControllerImage && !iSceneSettingModeActive )

   378                 {

   379                 iController.EnterViewfinderMode( ECamControllerImage );

   380                 }  

   381             }

   382         UpdateCbaL();

   383         }

   384       else

   385         {

   386         // Lens cover is not supported

   387         if ( iController.CameraSwitchQueued() )   

   388             {

   389             appUi->HandleCommandL( ECamCmdSwitchCamera );

   390             }

   391         }

   392 

   393 

   394       // Start the viewfinder unless the view is activating into standby mode

   395       // in other modes than scene setting mode (there is no VF and this causes problems with DSA VF)

   396       if ( ( !iStandbyModeActive || !iActivateToStandby )  && !iSceneSettingModeActive )

   397         {

   398         // If in embedded mode and image has been captured but view is not yet in

   399         // postcapture view VF should not be started.

   400         if( !iAssumePostCaptureView ) 

   401             {

   402             PRINT( _L("Camera <> CCamPreCaptureViewBase::HandleForegroundEventL start VF"))

   403             StartViewFinder();

   404             }

   405         }

   406     // Check if currently selected storagemedia has available memory for next capturing

   407     appUi->CheckMemoryAvailableForCapturing();                                   

   408     

   409     // <CAMERAAPP_CAPI_V2_MIGRATION/>

   410     // if ( iController.EngineState() == ECamEngineStillCapturePrepared ||

   411     //      iController.EngineState() == ECamEngineVideoCapturePrepared )

   412     // if ( ( ECamImageOn|ECamVideoOn )& ( iController.CameraState() ) )

   413     TCamCameraState state = iController.CameraState();

   414     if( ECamCameraPreparedImage == state ||

   415         ECamCameraPreparedVideo == state )     

   416       {

   417       // Now that the view is initialised, we may need to put up the

   418       // mmc removal note. Perform this is required.

   419       appUi->ShowMMCRemovalNoteIfRequiredL();                        

   420       

   421       if ( appUi && !iSceneSettingModeActive &&

   422            !( iController.UiConfigManagerPtr() && 

   423            iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )

   424         {

   425         appUi->RaisePreCaptureCourtesyUI(ETrue);

   426         }

   427       }

   428     }

   429   // -----------------------------------------------------

   430   // Going to the background

   431   else 

   432       {

   433       PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: to background" ) );    

   434       // Not behind an eikon/avkon server window

   435 	  // or keylock on when camera needs to be released.

   436       TBool totalBackground = ETrue;

   437       if ( iController.IsAppUiAvailable() && !iController.IsKeyLockOn() )

   438           {

   439           totalBackground    = appUi->AppInBackground( EFalse );

   440           }

   441       // Either in foreground (moving to another view of our's)

   442       // or if in background, then not just behind a notifier dialog.

   443       if ( totalBackground )

   444           {

   445           ReleaseResources();

   446           // hide the AP to avoid blinking when coming back from bg

   447          if ( iController.UiConfigManagerPtr() && iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )

   448             {

   449             appUi->SetActivePaletteVisibility( EFalse );	

   450             }      

   451           }

   452       // Behind a server window

   453       else 

   454           {

   455           iContinueInBackground = ETrue;            

   456           }

   457 

   458       // reset post capture assumption flag since post capture is not

   459       // used when video is stopped for usb 

   460       if ( iController.IsCaptureStoppedForUsb() )

   461           {

   462           iAssumePostCaptureView = EFalse;

   463           }

   464       }

   465   // -----------------------------------------------------

   466 

   467   if ( !iStandbyModeActive )

   468     {

   469     // Inform the container of foreground state change

   470     PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: inform container.." ) );        

   471     iContainer->HandleForegroundEventL( aForeground );

   472     }

   473   else

   474     {

   475     // if in videocall, don't exit standby	

   476     if ( iController.InVideocallOrRinging() )

   477         {

   478         iActivateToStandby = EFalse;

   479         }

   480     else    		

   481         {   	

   482         // If the view has been set to standby at activation then

   483         // the first foreground event should not be used to exit standby

   484         if ( !iActivateToStandby )

   485            {

   486            // inform standby container

   487            PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: inform standby container.." ) );        

   488            iStandbyContainer->HandleForegroundEventL( aForeground );

   489            }  

   490         else

   491            {

   492            iActivateToStandby = EFalse;

   493            }

   494         }

   495     }

   496          CCamCaptureSetupViewBase::HandleForegroundEventL( aForeground );

   497   PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL" ) );        

   498   }

   499 

   500 // -----------------------------------------------------------------------------

   501 // CCamPreCaptureViewBase::SetLocationTrailConnecting

   502 // Set iLocationTrailConnecting flag.

   503 // -----------------------------------------------------------------------------

   504 //

   505 void CCamPreCaptureViewBase::SetLocationTrailConnecting()

   506     {

   507     iLocationTrailConnecting = ETrue;

   508     }

   509 

   510 // -----------------------------------------------------------------------------

   511 // CCamPreCaptureViewBase::SetPostCaptureViewAsumption

   512 // Set iAssumePostCaptureView flag.

   513 // -----------------------------------------------------------------------------

   514 //

   515 void CCamPreCaptureViewBase::SetPostCaptureViewAsumption( TBool aAssumePostCaptureView )

   516     {

   517     iAssumePostCaptureView = aAssumePostCaptureView;

   518     }

   519 

   520 

   521 // -----------------------------------------------------------------------------

   522 // CCamPreCaptureViewBase::HandleControllerEventL

   523 // Handle controller events

   524 // -----------------------------------------------------------------------------

   525 //

   526 void CCamPreCaptureViewBase::HandleControllerEventL( TCamControllerEvent aEvent, 

   527                                                      TInt /*aError*/ )

   528   {

   529   PRINT( _L( "Camera => CCamPreCaptureViewBase::HandleControllerEventL" ) );        

   530   CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   531 

   532   switch( aEvent )

   533     { 

   534     // ---------------------------------------------------

   535     case ECamEventEngineStateChanged:

   536       {

   537       // Do not do softkey update if we are already exiting

   538       // (AppUi is not available)

   539       if( iController.IsAppUiAvailable() )

   540       {          

   541       PRINT( _L( "Camera <> case ECamEventEngineStateChanged" ) );        

   542       if ( ECamCameraPreparedVideo == iController.CameraState() || 

   543            ECamCameraPreparedImage == iController.CameraState() )

   544         {

   545         // Now that the view is initialised, we may need to put up the

   546         // mmc removal note. Perform this is required.

   547         PRINT( _L( "Camera <> show mmc note if needed" ) );        

   548         appUi->ShowMMCRemovalNoteIfRequiredL();

   549 

   550         // Do not update (show) precapture view toolbar if capturing is almost

   551         // finished, otherwise there is flickering and finally inactive toolbar 

   552         // when returning to prepactureview after image deletion. 

   553         // This will happen only if camera is started directly to portrait 

   554         // secondary camera i.e. Lens cover feature is supported

   555         TBool noToolbar = ( ECamCompleting == iController.CurrentOperation() ) && appUi->IsSecondCameraEnabled();

   556 

   557         TBool showVideoModeToolbar = ( ECamCameraPreparedVideo == iController.CameraState() && 

   558                 ( iController.CurrentOperation() != ECamCapturing && iController.CurrentOperation() != ECamPaused ) );

   559 

   560         TBool precaptureToolbarState = !appUi->IsBurstEnabled()

   561                 && !iStandbyModeActive && !appUi->IsInPretendExit();

   562         

   563         if ( ( ECamCameraPreparedImage == iController.CameraState() || 

   564                 showVideoModeToolbar ) &&     

   565                !noToolbar && precaptureToolbarState )

   566             {

   567             // Also fixed toolbar might need to be enabled.

   568             appUi->SetToolbarVisibility();

   569             }

   570         }

   571       //Do not update CBA if we are capturing or paused to prevent blinking

   572 	  //during video capture saving and completing

   573       if ( iController.CurrentVideoOperation() != ECamCapturing

   574              && iController.CurrentVideoOperation() != ECamPaused )

   575           {

   576           PRINT( _L( "Camera <> Update CBA" ) );        

   577           UpdateCbaL();

   578           }

   579       }

   580       break;

   581       }

   582 

   583     case ECamEventSliderClosed:

   584       {

   585       // if embedded and the slider is closed, 

   586       // the menu items may change, close the menu   

   587       if( iEmbedded )

   588         {

   589         PRINT( _L("Camera <> CCamPreCaptureViewBase: calling StopDisplayingMenuBar") );

   590         StopDisplayingMenuBar();

   591         }

   592       break;

   593       }

   594     default:

   595       {

   596       // Other events => no action.

   597       break;

   598       }

   599     } // switch

   600   PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleControllerEventL" ) );        

   601   }

   602 

   603 // ---------------------------------------------------------------------------

   604 // CCamPreCaptureViewBase::DoActivateL

   605 // Activate this view

   606 // ---------------------------------------------------------------------------

   607 //

   608 void CCamPreCaptureViewBase::DoActivateL( const TVwsViewId& aPrevViewId, 

   609                                           TUid aCustomMessageId,

   610                                           const TDesC8& aCustomMessage )                                                                                    

   611     {

   612     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMPRECAPTUREVIEWBASE_DOACTIVATEL, "e_CCamPreCaptureViewBase_DoActivateL 1" );

   613     PRINT( _L( "Camera => CCamPreCaptureViewBase::DoActivateL" ) );

   614     iAssumePostCaptureView = EFalse;

   615     iLastMovement = 0;

   616 

   617     ShowToolbarOnViewActivation( EFalse );

   618     /*if ( iController.UiConfigManagerPtr() && 

   619          iController.UiConfigManagerPtr()->IsLocationSupported() )

   620         {

   621         if( ECamLocationOn == iController.IntegerSettingValue( ECamSettingItemRecLocation ) )

   622             {

   623             if( ECamActiveCameraPrimary == iController.ActiveCamera() && ECamStandby != iController.CurrentOperation() )

   624                 {

   625                 PRINT( _L("Camera: CCamPreCaptureViewBase::DoActivateL - primary camera, start location/gps") )

   626                 iController.StartLocationTrailL();

   627                 }

   628             else // Secondary camera 

   629                 {

   630                 PRINT( _L("Camera: CCamPreCaptureViewBase::DoActivateL - secondary camera, stop location trail") )

   631                 iController.StopLocationTrail();

   632                 }

   633             }

   634         }*/

   635  

   636     CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );

   637 	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));

   638     if(!appUi->DrawPreCaptureCourtesyUI() && !iController.IsTouchScreenSupported())

   639         {

   640         if ( !appUi->IsSecondCameraEnabled() )

   641             {	

   642             SetCourtesySoftKeysL();

   643             }

   644         appUi->SetActivePaletteVisibility( EFalse );

   645         }

   646     else if (appUi->DrawPreCaptureCourtesyUI())

   647         {

   648          Cba()->MakeVisible( ETrue );

   649         }

   650 

   651     if ( appUi->SettingsLaunchedFromCamera() )

   652     	{

   653     	if ( TUid::Uid( ECamCmdInternalExit ) == aCustomMessageId )

   654     	    {

   655             appUi->SettingsPluginExitedL( ECameraInternalExit );

   656     	    }

   657     	else if ( TUid::Uid ( EAknSoftkeyBack ) == aCustomMessageId )

   658     	    {

   659     	    appUi->SettingsPluginExitedL( ECameraPluginExit );

   660     	    }

   661     	else

   662     	    {

   663     	    // do nothing

   664     	    }

   665     	}

   666 

   667     CCamCaptureSetupViewBase::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );

   668 

   669     if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() )  

   670         {

   671         StatusPane()->MakeVisible( ETrue );

   672         }

   673     else

   674         {

   675         StatusPane()->MakeVisible( EFalse );

   676         }

   677     

   678     if ( iController.IsTouchScreenSupported() )

   679         {

   680         // Make sure that icons are upto date

   681         UpdateToolbarIconsL();

   682     

   683         CAknToolbar* fixedToolbar = Toolbar();

   684         if ( fixedToolbar )

   685             {

   686             // If video call is active, toolbar is set to dimmed, that user cannot use it

   687             TInt callType( EPSCTsyCallTypeUninitialized );

   688             RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType );

   689             if ( callType == EPSCTsyCallTypeH324Multimedia)

   690                 {

   691                 fixedToolbar->SetDimmed( ETrue ); 

   692                 }

   693             else

   694                 {

   695                 fixedToolbar->SetDimmed( EFalse ); 

   696                 }

   697             fixedToolbar->SetToolbarObserver( this );

   698             // avoid toolbar flicker when returning from user scene setup 

   699             // after adjusting a setting

   700             if ( !iSceneSettingModeActive )

   701                 {

   702                 appUi->SetToolbarVisibility( );

   703                 }

   704    

   705             // Make sure toolbar extension button has no background

   706             CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();

   707             if ( extension )

   708                 {

   709                 extension->SetButtonFlags(

   710                     extension->ButtonFlags() | KAknButtonNoFrame );

   711                 extension->DrawDeferred();

   712                 }

   713             }

   714         }

   715 

   716     appUi->PushNaviPaneCounterL();

   717 

   718     // Pass on the ID of the previous view to the container    

   719     TCamAppViewIds viewId = static_cast<TCamAppViewIds>( aPrevViewId.iViewUid.iUid );

   720     iContainer->SetPreviousViewId( viewId );

   721 

   722     iController.AddControllerObserverL( this );    

   723 

   724     TBool transparentCba = EFalse;

   725 

   726     UpdateCbaL();

   727     

   728     switch( aCustomMessageId.iUid )

   729       {

   730       // -------------------------------

   731       // Standby with or without error

   732       case ECamViewMessageStandby:

   733         PRINT( _L( "Camera <> CCamPreCaptureViewBase::DoActivateL: custom message ECamViewMessageStandby" ) );

   734         //iStandbyError = KErrNone;

   735         //appUi->SetStandbyStatus( KErrNone );

   736         SetSceneSettingMode( EFalse );

   737         iActivateToStandby = ETrue;

   738         HandleCommandL( ECamCmdGoToStandby );

   739         return;

   740 //        break;

   741       // -------------------------------

   742       // Scene setting mode

   743       case ECamViewMessageSceneSettingList:

   744         PRINT( _L( "Camera <> CCamPreCaptureViewBase::DoActivateL: custom message ECamViewMessageSceneSettingList" ) );

   745         SwitchToSceneSettingModeL();

   746         break;

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

   748       default:

   749         // Other precapture modes have transparent CBA buttons

   750         // except secondary camera

   751         if ( !appUi->IsSecondCameraEnabled() || appUi->IsQwerty2ndCamera() )  

   752             {

   753             transparentCba = ETrue;

   754             }

   755         // don't start VF if faster startup is used when cameraswitch is queued,

   756         // need to switch to maincamera first

   757         if ( !( iController.UiConfigManagerPtr() && 

   758                 iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() &&

   759                 iController.CameraSwitchQueued() ) )

   760             {

   761             StartViewFinder();

   762             }

   763         

   764         break;

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

   766       }

   767     

   768     // Here we check if the previous view is ViaPlayer play mode

   769     if ( !iSceneSettingModeActive  && 

   770          ( aPrevViewId.iViewUid.iUid != ECamViewIdViaPlayerPlayBack ) && 

   771          !( iController.UiConfigManagerPtr() && 

   772          iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )

   773         {

   774         appUi->RaisePreCaptureCourtesyUI(ETrue);

   775         }

   776     

   777     // Reset iContinueInBackground flag, which is set when app temporarily

   778     // goes behind a system window and there's no need to free resources.

   779     // Resetting this flag only in ReleaseResources causes problems (at least)

   780     // if power key is pressed during burst capture.

   781     iContinueInBackground = EFalse;

   782     

   783     // Reset iDeactivateToStandby flag, which is used when the PreCapture view

   784     // goes to the Standby mode, at which point the UI should not reactivate the

   785     // viewfinder.

   786     iDeactivateToStandby = EFalse;

   787 

   788 

   789     EikSoftkeyPostingTransparency::MakeTransparent(

   790         *Cba(), transparentCba );

   791     // Make sure appuis CBA is not visible

   792     CEikButtonGroupContainer* cba = AppUi()->Cba();

   793     if( cba )

   794         {

   795         cba->MakeVisible( EFalse );

   796         }

   797 

   798     PRINT( _L( "Camera <= CCamPreCaptureViewBase::DoActivateL" ) );

   799     OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMPRECAPTUREVIEWBASE_DOACTIVATEL, "e_CCamPreCaptureViewBase_DoActivateL 0" );

   800     }

   801 

   802 // ---------------------------------------------------------------------------

   803 // CCamPreCaptureViewBase::DoDeactivate

   804 // Deactivate this view

   805 // ---------------------------------------------------------------------------

   806 //

   807 void CCamPreCaptureViewBase::DoDeactivate()

   808     {                              

   809     PRINT( _L( "Camera => CCamPreCaptureViewBase::DoDeactivate" ) );

   810     

   811     delete iGestureFw;

   812     iGestureFw = NULL;

   813 

   814     CCamCaptureSetupViewBase::DoDeactivate();

   815                                

   816     iController.RemoveControllerObserver( this );

   817     

   818     if ( iController.IsTouchScreenSupported() )

   819         {

   820         CAknToolbar* fixedToolbar = Toolbar();

   821         if ( fixedToolbar )

   822             {

   823             CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();

   824             if ( extension )

   825                 {

   826                 // Reset toolbar extension button and view to closed state

   827                 extension->SetShown( EFalse );

   828                 extension->SetCurrentState( 0, EFalse );

   829                 }

   830             }

   831         }

   832     ReleaseResources();

   833 

   834     if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() &&

   835          iController.ActiveCamera() == ECamActiveCameraSecondary ) 

   836         {

   837         if ( iController.CameraSwitchQueued() )

   838             {

   839             CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

   840             // If camera switch fails, main camera is used instead

   841             TRAP_IGNORE( appUi->HandleCommandL( ECamCmdSwitchCamera ) );

   842             }

   843         }

   844 

   845     PRINT( _L( "Camera <= CCamPreCaptureViewBase::DoDeactivate" ) );

   846     }

   847 

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

   849 // CCamPreCaptureViewBase::HandleFocusLossL

   850 // Handle change of focus

   851 // -----------------------------------------------------------------------------

   852 //

   853 void CCamPreCaptureViewBase::HandleFocusLossL()

   854     {

   855     PRINT( _L( "Camera => CCamPreCaptureViewBase::HandleFocusLossL" ) );    

   856     // if the application was already in the background, but behind an

   857     // eikon server window, then handle backgrounding properly now.

   858     // Otherwise the backgrounding will be handled in the normal

   859     // HandleForeground() method.

   860     if ( iContinueInBackground )

   861         {

   862         ReleaseResources();

   863         // Inform the container of foreground state change

   864         iContainer->HandleForegroundEventL( EFalse );

   865         }

   866     CCamCaptureSetupViewBase::HandleFocusLossL();

   867 

   868     // dismiss menu bar if open

   869     StopDisplayingMenuBar();

   870     PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleFocusLossL" ) );

   871     }

   872                           

   873 // ---------------------------------------------------------------------------

   874 // CCamPreCaptureViewBase::SwitchToCaptureSetupModeL

   875 // Switches the current mode to capture setup and activates a 

   876 // specific control..

   877 // ---------------------------------------------------------------------------

   878 //

   879 void CCamPreCaptureViewBase::SwitchToCaptureSetupModeL( TInt aSetupCommand )

   880     {

   881     

   882     PRINT( _L("Camera => CCamPreCaptureViewBase::SwitchToCaptureSetupModeL") );

   883     

   884     // Remove the view's main container, and add the capture setup 

   885     // control associated with the input command to the container stack.

   886     CCamCaptureSetupViewBase::SwitchToCaptureSetupModeL( aSetupCommand );

   887 

   888     // only remove the capture setup menu container after 

   889     // the switch completes successfully

   890     RemoveCaptureSetupMenuContainers();

   891 

   892     SetCaptureSetupModeActive(ETrue);

   893     

   894     PRINT( _L("Camera <= CCamPreCaptureViewBase::SwitchToCaptureSetupModeL") );

   895     }

   896 

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

   898 // CCamPreCaptureViewBase::SwitchToSceneSettingModeL

   899 // Switches the current mode to scene setting and activates a 

   900 // specific control.

   901 // ---------------------------------------------------------------------------

   902 //

   903 void CCamPreCaptureViewBase::SwitchToSceneSettingModeL()

   904     {

   905     // Remove the view's main container, and add the capture setup 

   906     // control associated with the input command to the container stack.

   907     CCamCaptureSetupViewBase::SwitchToSceneSettingModeL();

   908  

   909     // only remove the capture setup menu container after 

   910     // the switch completes successfully

   911     RemoveCaptureSetupMenuContainers();

   912     }

   913 

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

   915 // CCamPreCaptureViewBase::ExitCaptureSetupModeL

   916 // Exits capture setup mode and activates the capture setup menu control.

   917 // ---------------------------------------------------------------------------

   918 //

   919 void CCamPreCaptureViewBase::ExitCaptureSetupModeL()

   920     {

   921     PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL") )

   922      

   923     CCamCaptureSetupViewBase::ExitCaptureSetupModeL();    

   924     iController.SetViewfinderWindowHandle( &iContainer->Window() );

   925 

   926     

   927     if( !iController.IsViewFinding() && !iController.InVideocallOrRinging() )

   928       {

   929       TCamCameraMode mode = iController.CurrentMode();    

   930 	  PRINT1( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL - CurrentMode %d"), mode );        

   931       if (mode == ECamControllerVideo )

   932     	{

   933    	    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL - ECamControllerVideo") );        

   934     	iController.EnterViewfinderMode( ECamControllerVideo );

   935     	}    	

   936       else

   937     	{

   938    	    PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL - ECamControllerImage") );        

   939       iController.EnterViewfinderMode( ECamControllerImage );

   940     	}    	               

   941       }

   942     

   943     // make sure app is not left in an invalid state if a leave

   944     // occurs after exiting the capture setup

   945     iCaptureSetupMenuModeActive = EFalse;

   946     static_cast<CCamAppUiBase*>( AppUi() )->PushNaviPaneCounterL();

   947 	CCamAppUiBase* appUi =  static_cast<CCamAppUiBase*>( AppUi() );

   948 	if( appUi->ActiveCamera() == ECamActiveCameraSecondary )

   949 		{

   950 		PRINT( _L("Camera => CCamPreCaptureViewBase::ExitCaptureSetupModeL ###") )

   951     	SwitchToCaptureSetupMenuModeL();

   952 		}

   953 	

   954 	UpdateCbaL();

   955     PRINT( _L("Camera <= CCamPreCaptureViewBase::ExitCaptureSetupModeL") )

   956     }

   957 

   958 // ---------------------------------------------------------------------------

   959 // CCamPreCaptureViewBase::ExitSceneSettingModeL

   960 // Exits scene setting mode and activates the capture setup menu control.

   961 // ---------------------------------------------------------------------------

   962 //

   963 void CCamPreCaptureViewBase::ExitSceneSettingModeL()

   964     {

   965     CCamCaptureSetupViewBase::ExitSceneSettingModeL();

   966     // make sure app is not left in an invalid state if a leave

   967     // occurs after exiting the scene setting mode

   968     iCaptureSetupMenuModeActive = EFalse;

   969     static_cast<CCamAppUiBase*>( AppUi() )->PushNaviPaneCounterL();

   970 

   971 	CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );

   972     if ( appUi->ActiveCamera() == ECamActiveCameraPrimary )

   973         {

   974         if ( iDeactivateToStandby || iController.InVideocallOrRinging() )

   975             {

   976             // don't restart VF if we are going to standby mode

   977             }

   978         else

   979             {

   980             StartViewFinder();

   981             }

   982         }

   983     else

   984 		{

   985 		SwitchToCaptureSetupMenuModeL();

   986 		}

   987     }

   988 

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

   990 // CCamPreCaptureViewBase::ExitInfoListBoxL

   991 // Exits InfoListBox

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

   993 //

   994 void CCamPreCaptureViewBase::ExitInfoListBoxL()

   995     {

   996     CCamCaptureSetupViewBase::ExitInfoListBoxL();

   997     // make sure app is not left in an invalid state if a leave

   998     // occurs after exiting the scene setting mode

   999     iCaptureSetupMenuModeActive = EFalse;

  1000     static_cast<CCamAppUiBase*>( AppUi() )->PushNaviPaneCounterL();

  1001 

  1002 	CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );

  1003     if ( appUi->ActiveCamera() == ECamActiveCameraPrimary )

  1004         {

  1005         StartViewFinder();

  1006         }

  1007     else

  1008 		{

  1009 		SwitchToCaptureSetupMenuModeL();

  1010 		}

  1011     }

  1012 

  1013 

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

  1015 // CCamPreCaptureViewBase::ExitAllModesL

  1016 // Revert to normal mode

  1017 // -----------------------------------------------------------------------------

  1018 //

  1019 void 

  1020 CCamPreCaptureViewBase::ExitAllModesL()

  1021   {

  1022   PRINT( _L("Camera => CCamPreCaptureViewBase::ExitAllModesL" ) );

  1023   iController.DeepSleepTimerCancel();

  1024   TCamSettingMode currentMode = ActiveSettingMode();

  1025   

  1026   CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );

  1027   

  1028   switch ( currentMode )

  1029     {

  1030     case ECamSettingModeCaptureMenu:

  1031       {

  1032       PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL cap setup menu" ))

  1033       ExitCaptureSetupMenuModeL();

  1034       break;

  1035       }

  1036     case ECamSettingModeCapture:

  1037       {

  1038       PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL capture" ))

  1039       

  1040       ExitCaptureSetupModeL();

  1041       if( appUi->ActiveCamera() == ECamActiveCameraSecondary  )

  1042         {

  1043         PRINT( _L("Camera <> CamPreCaptureViewBase::ExitAllModesL ##" )) 

  1044         ExitCaptureSetupMenuModeL();

  1045         }

  1046       break;

  1047       }

  1048     case ECamSettingModeScene:

  1049       {

  1050       PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL scene" ))

  1051 	  ExitSceneSettingModeL();

  1052       if( appUi->ActiveCamera() == ECamActiveCameraSecondary  )

  1053         {

  1054         PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL ##" )) 

  1055         ExitCaptureSetupMenuModeL();

  1056         }

  1057 	  if( Id() == TUid::Uid( ECamViewIdVideoPreCapture ) &&

  1058           iController.UiConfigManagerPtr() &&

  1059           iController.UiConfigManagerPtr()->IsXenonFlashSupported() )

  1060 		{

  1061 		iToolbarExtensionInvisible = ETrue;

  1062 		}

  1063       break;

  1064       }

  1065     case ECamSettingModeInfoListBox:

  1066       {

  1067       PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL generic" ))

  1068       ExitInfoListBoxL();

  1069       if( appUi->ActiveCamera() == ECamActiveCameraSecondary  )

  1070         {

  1071         PRINT( _L("Camera <> CCamPreCaptureViewBase::ExitAllModesL ##" )) 

  1072         ExitCaptureSetupMenuModeL();

  1073         }            

  1074       break;

  1075       }            

  1076     default:

  1077       {

  1078       iToolbarExtensionInvisible = ETrue;    	

  1079       }

  1080       break;

  1081     }

  1082 

  1083   if ( iController.InVideocallOrRinging() || !iController.IssueModeChangeSequenceSucceeded() )

  1084       {

  1085       return;

  1086       }	

  1087   

  1088   appUi->HandleCommandL(ECamCmdSwitchToPrecapture);

  1089   

  1090 

  1091   if ( !( iController.UiConfigManagerPtr() && 

  1092             iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )

  1093     {

  1094     TCamOrientation orientation = appUi->CamOrientation();

  1095     if ( orientation == ECamOrientationCamcorder || orientation == ECamOrientationCamcorderLeft )

  1096       {

  1097       // force update of active palette

  1098       appUi->APHandler()->UpdateActivePaletteL();                    

  1099       }

  1100 

  1101     if ( appUi && !iSceneSettingModeActive )

  1102       {

  1103       appUi->RaisePreCaptureCourtesyUI(ETrue);

  1104       }

  1105     }

  1106     

  1107   if ( iController.IsTouchScreenSupported() )

  1108       {

  1109       CAknToolbar* fixedToolbar = Toolbar();

  1110       CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();

  1111       

  1112       // Only active view will set toolbar extension visibility.

  1113       if( this->IsForeground() )

  1114           {

  1115           if ( extension && iToolbarExtensionInvisible == EFalse )

  1116               {

  1117               extension->SetShown( ETrue );

  1118               }

  1119           else if( extension )

  1120               {

  1121               extension->SetShown( EFalse );

  1122               }

  1123           }

  1124 

  1125       iToolbarExtensionInvisible = EFalse;

  1126       }

  1127     

  1128   PRINT( _L("Camera <= CCamPreCaptureViewBase::ExitAllModesL" ) );

  1129   }

  1130 

  1131 

  1132 // ---------------------------------------------------------------------------

  1133 // CCamPreCaptureViewBase::ActiveSettingMode

  1134 // Returns the active setting mode