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

    15 */

    16 

    17 

    18 

    19 // INCLUDE FILES

    20 #include <eikmenub.h>

    21 #include <aknview.h>

    22 #include <w32std.h>

    23 #include <gulutil.h>

    24 #include <AknIconUtils.h>

    25 #include <barsread.h>    // resource reader

    26 #include <AknsFrameBackgroundControlContext.h>

    27 #include <AknsDrawUtils.h>

    28 #include <eikenv.h>

    29 #include <eikappui.h> // For CCoeAppUiBase

    30 #include <eikapp.h>   // For CEikApplication

    31 #include <layoutmetadata.cdl.h>            

    32 #include <aknlayoutscalable_apps.cdl.h>    

    33 

    34 #include <cameraapp.mbg>

    35 #include <cameraapp.rsg>

    36 #include <vgacamsettings.rsg>

    37 

    38 

    39 #include "CamAppUiBase.h"

    40 #include "CamPreCaptureContainerBase.h"

    41 #include "CamLogger.h"

    42 #include "CamSidePane.h"

    43 #include "CamUtility.h"

    44 #include "CamPanic.h"

    45 #include "Cam.hrh"

    46 #include "CamAppUi.h"   

    47 #include "CamIndicator.h"

    48 #include "CamIndicatorResourceReader.h"

    49 #include "CamIndicatorData.h"

    50 #include "CamSelfTimer.h"

    51 #include "CamPreCaptureViewBase.h"

    52 #include "CamStillPreCaptureView.h"

    53 #include "CamSettings.hrh"

    54 #include "CamNaviCounterControl.h"

    55 #include "CamNaviProgressBarControl.h"

    56 #include "camuiconstants.h" // KCamDirectColorVal

    57 #include "camactivepalettehandler.h"

    58 #include "OstTraceDefinitions.h"

    59 #ifdef OST_TRACE_COMPILER_IN_USE

    60 #include "CamPreCaptureContainerBaseTraces.h"

    61 #endif

    62 #include "camconfiguration.h"

    63 #include "CameraUiConfigManager.h"

    64 

    65 

    66 // CONSTANTS

    67 const TInt KZoomPanelTimeout = 4000000;     // 4s 

    68 const TInt KReticuleFlashTimeout = 250000;  // Quarter of a second (in microseconds).

    69 const TInt KAFIconCorners = 4; // Hip to be square 

    70 

    71 #include "camvfgridinterface.h"

    72 #include "camlinevfgriddrawer.h"

    73 

    74 // Snapshot data is needed in timelapse mode

    75 const TUint KCameraEventInterest = ( ECamCameraEventClassVfControl      

    76                                    | ECamCameraEventClassVfData 

    77                                    | ECamCameraEventClassSsData 

    78                                    );

    79 

    80 

    81 

    82 // ================= MEMBER FUNCTIONS =======================

    83 

    84 // ---------------------------------------------------------

    85 // CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase

    86 // Destructor

    87 // ---------------------------------------------------------

    88 //

    89 CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase()

    90   {

    91   PRINT( _L("Camera => ~CCamPreCaptureContainerBase" ))

    92   

    93   iController.ViewfinderWindowDeleted( &Window() );

    94   

    95   iController.RemoveSettingsObserver  ( this );

    96   iController.RemoveCameraObserver    ( this );

    97   iController.RemoveControllerObserver( this );    

    98   

    99     if ( iZoomTimer && iZoomTimer->IsActive() )

   100     {    

   101     iZoomTimer->Cancel();

   102     }

   103   delete iZoomTimer;

   104   delete iVfGridDrawer;

   105 

   106   if ( iController.UiConfigManagerPtr() && 

   107        iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

   108       {

   109       iAfIcons.ResetAndDestroy();

   110       iLayouts.Close(); 

   111       if ( iReticuleTimer && iReticuleTimer->IsActive() )

   112         {    

   113         iReticuleTimer->Cancel();

   114         }

   115       delete iReticuleTimer;    

   116       }

   117 

   118   CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

   119 

   120   iResolutionIndicators.ResetAndDestroy();

   121   iResolutionIndicators.Close();

   122   if ( iController.UiConfigManagerPtr() && 

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

   124       {

   125       PRINT( _L("Camera => ~CCamPreCaptureContainerBase - delete iLocationIconController" ))

   126       delete iLocationIconController;

   127       }

   128 

   129   delete iOffScreenBitmap;

   130   delete iBitmapDevice;

   131   delete iBitmapGc;

   132   

   133   // if shutting down, observers are removed automatically  

   134   if ( 

   135       iController.IsAppUiAvailable() &&

   136       appUi && !iController.IsInShutdownMode() )

   137     {

   138     // Deregister as burst mode observer

   139     appUi->RemoveBurstModeObserver( this );

   140     }

   141 

   142   delete iBatteryPaneController;

   143   

   144   delete iViewFinderBackup;

   145   iViewFinderBackup = NULL;

   146   iReceivedVfFrame = EFalse;

   147 

   148   PRINT( _L("Camera <= ~CCamPreCaptureContainerBase" ))

   149   }

   150 

   151 // ---------------------------------------------------------

   152 // CCamPreCaptureContainerBase::BaseConstructL

   153 // Symbian OS 2nd phase constructor

   154 // ---------------------------------------------------------

   155 //

   156 void CCamPreCaptureContainerBase::BaseConstructL( const TRect& aRect )

   157   {

   158   PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL ") );

   159   

   160   CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

   161   iZoomPane = appUi->ZoomPane();

   162   

   163   CCamContainerBase::BaseConstructL( aRect );

   164   

   165   iViewFinderBackup = NULL;

   166   iReceivedVfFrame = EFalse;

   167   

   168   // Check whether zoom & side pane will be on the left or the right of the screen

   169   TInt handedInt;

   170   User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiSidePanePosition, handedInt ) );

   171   iHandedness = static_cast< TCamHandedness >( handedInt );

   172 

   173   TResourceReader reader;                                                                                     

   174   iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_ZOOM_PANE_WIDTH_ID));    

   175   iZoomPaneWidth = reader.ReadInt16();

   176   CleanupStack::PopAndDestroy(); // reader

   177   

   178   // Create Zoom Pane based on Rect passed in on creation

   179   TRect paneRect( Rect() );

   180 

   181   // if the side pane is on the left

   182   if ( iHandedness == ECamHandLeft ) 

   183     { 

   184     paneRect.iBr.iX = iZoomPaneWidth;

   185     }

   186   else // the side pane is on the right

   187     {

   188     paneRect.iTl.iX = paneRect.iBr.iX - iZoomPaneWidth;    

   189     }

   190   

   191   User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiOverLaySidePane, iOverlayViewFinder ) );

   192 

   193   iController.AddControllerObserverL( this ); // For zoom state changes

   194   iController.AddCameraObserverL( this, KCameraEventInterest );

   195   iController.AddSettingsObserverL( this );

   196 

   197   iZoomPane->MakeVisible( EFalse, EFalse ); // On app startup, it's invisible

   198 

   199   if ( !appUi->IsSecondCameraEnabled() )

   200     {

   201     iZoomPane->SetZoomKeys( iPrimaryZoomInKeys, iPrimaryZoomOutKeys );

   202     }

   203   else

   204     {     

   205     iZoomPane->SetZoomKeys( iSecondaryZoomInKeys, iSecondaryZoomOutKeys );

   206     }

   207   

   208   iZoomTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

   209   

   210   if ( iController.UiConfigManagerPtr() && 

   211        iController.UiConfigManagerPtr()->IsAutoFocusSupported() &&

   212        !iController.UiConfigManagerPtr()->IsFaceTrackingSupported() )

   213       {

   214       iReticuleTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

   215     

   216       // Layout the reticule.                                                                                           

   217       iAfReadyIcon = CreateAfIconL( KRgbWhite );

   218       iAfFocusIcon = CreateAfIconL( KRgbGreen );

   219       iAfErrIcon   = CreateAfIconL( KRgbRed );

   220       }

   221 

   222   iSidePane = appUi->SidePane();

   223   iSidePane->SetRect( paneRect );

   224 

   225   // Register as burst mode observer

   226   appUi->AddBurstModeObserverL( this );

   227   

   228   CreateResolutionIndicatorL();

   229   

   230   if ( iController.UiConfigManagerPtr() && 

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

   232       {

   233       TRect Locrect = Rect();

   234       PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL - create iLocationIconController") )

   235       iLocationIconController = CCamLocationIconController::NewL( iController, *this, ETrue, Locrect );

   236       SetLocationIndicatorVisibility();

   237       }

   238 

   239   TBool dsaAlways( EFalse ); // Offscreen bitmap is needed with the emulator

   240   #ifndef __WINS__

   241   dsaAlways = iController.IsDirectScreenVFSupported( ETrue ) && 

   242               iController.IsDirectScreenVFSupported( EFalse );

   243   #endif

   244                  

   245   if ( !dsaAlways )

   246       {

   247       // If bitmap VF is not possible in this configuration, 

   248       // offscreen bitmap is not needed

   249       TInt color;

   250       TInt gray;

   251   

   252       TDisplayMode displaymode =

   253           CEikonEnv::Static()->WsSession().GetDefModeMaxNumColors( color, gray );

   254   

   255       // set up the offscreen bitmap

   256       iOffScreenBitmap = new ( ELeave ) CFbsBitmap();  

   257   

   258       User::LeaveIfError( iOffScreenBitmap->Create( Rect().Size(), EColor16MU/*displaymode*/ ) );

   259   

   260       PRINT1( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL disp mode (%d)"), displaymode )

   261       iBitmapDevice = CFbsBitmapDevice::NewL( iOffScreenBitmap );

   262       User::LeaveIfError( iBitmapDevice->CreateContext( iBitmapGc ) );

   263       }

   264 

   265   iRect = ViewFinderFrameRect();

   266   // if using direct viewfinding pass Rect to control

   267 

   268 

   269   if ( iController.UiConfigManagerPtr() && 

   270        iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

   271       {

   272       // Check whether we should be showing the reticule.

   273       // NOTE: This will only be showed in still, not video views

   274       iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

   275       }

   276 

   277   // Setup viewfinder grid

   278   InitVfGridL( iRect );

   279 

   280   // Do not construct battery pane controller, if secondary camera is in use

   281   if ( iController.ActiveCamera() != ECamActiveCameraSecondary || 

   282        appUi->IsQwerty2ndCamera() ) 

   283     {

   284     iBatteryPaneController = CCamBatteryPaneController::NewL( 

   285                              *this, ETrue);  

   286     }

   287     // Make sure fixed toolbar is on top of this window

   288     DrawableWindow()->SetOrdinalPosition( KCamPreCaptureWindowOrdinalPos );

   289 

   290   iController.SetViewfinderWindowHandle( &Window() );

   291   appUi->SetViewFinderInTransit(EFalse);

   292   iController.StartIdleTimer();

   293   

   294   PRINT( _L("Camera <= CCamPreCaptureContainerBase::BaseConstructL ") );

   295   }

   296 

   297 // ---------------------------------------------------------------------------

   298 // CCamPreCaptureContainerBase::CCamPreCaptureContainerBase

   299 // C++ constructor

   300 // ---------------------------------------------------------------------------

   301 //

   302 CCamPreCaptureContainerBase::CCamPreCaptureContainerBase(

   303         CCamAppController& aController,

   304         CAknView& aView )

   305   : CCamContainerBase( aController, aView ),   

   306     iDisableRedraws( EFalse )

   307   {

   308   }

   309 

   310 // ---------------------------------------------------------------------------

   311 // CCamPreCaptureContainerBase::ZoomTimerCallback

   312 // Callback for Zoom Pane timer

   313 // ---------------------------------------------------------------------------

   314 //

   315 TInt CCamPreCaptureContainerBase::ZoomTimerCallback( TAny* aObject )

   316     {

   317     CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );

   318     cont->ZoomTimerTick();

   319     return KErrNone;

   320     }

   321 

   322 // ---------------------------------------------------------------------------

   323 // CCamPreCaptureContainerBase::ReticuleTimerCallback

   324 // Callback for flashing of the focus reticule

   325 // ---------------------------------------------------------------------------

   326 //

   327 TInt CCamPreCaptureContainerBase::ReticuleTimerCallback( TAny* aObject )

   328     {

   329     CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );

   330     cont->iReticuleFlashOn = !cont->iReticuleFlashOn;

   331 

   332     // This is where we force a redraw of the reticule, if we are using

   333     // Direct Viewfinding.  However, if we are in burst mode, we must

   334     // use Bitmap Viewfinding, so only draw reticule if NOT in burst mode

   335     CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

   336     if ( appUi && appUi-> IsDirectViewfinderActive() )

   337         {

   338         cont->DrawDeferred();

   339         }

   340     return KErrNone;

   341     }

   342     

   343 

   344 // ---------------------------------------------------------------------------

   345 // CCamPreCaptureContainerBase::ShowZoomPaneWithTimer

   346 // Makes Zoom Pane visible for the period of the pane timer.

   347 // ---------------------------------------------------------------------------

   348 //

   349 void CCamPreCaptureContainerBase::ShowZoomPaneWithTimer()

   350     {

   351     __ASSERT_DEBUG( iZoomTimer, CamPanic( ECamPanicNullPointer ) );

   352     __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );  

   353     __ASSERT_DEBUG( iSidePane, CamPanic( ECamPanicNullPointer ) ); 

   354 

   355     PRINT(_L("Camera => CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    

   356 

   357     // If already active, cancel the timer

   358     if ( iZoomTimer->IsActive() )

   359         {    

   360         iZoomTimer->Cancel();

   361         }

   362 

   363     iZoomTimer->Start( KZoomPanelTimeout, KZoomPanelTimeout, TCallBack( ZoomTimerCallback , this) );

   364     

   365     iZoomPane->MakeVisible( ETrue, ETrue );

   366 

   367     PRINT(_L("Camera <= CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    

   368     }

   369 

   370 // ---------------------------------------------------------------------------

   371 // CCamPreCaptureContainerBase::ZoomTimerTick

   372 // Called as a result of the Zoom Pane timer expiring, switches side panes

   373 // to hide the Zoom pane.

   374 // ---------------------------------------------------------------------------

   375 //

   376 void CCamPreCaptureContainerBase::ZoomTimerTick()

   377     {

   378     PRINT(_L("Camera => CCamPreCaptureContainerBase::ZoomTimerTick")); 

   379     // Cancel the (potentially) recurring timer

   380     iZoomTimer->Cancel();

   381 

   382     // If zooming is still in progress (this happens if the zoom key has

   383     // been held down longer than the zoom pane timer), keep the pane

   384     // visible

   385     if ( iZoomPane->IsCurrentlyZooming() )

   386         {

   387         iZoomTimer->Start( KZoomPanelTimeout,

   388                            KZoomPanelTimeout, 

   389                            TCallBack( ZoomTimerCallback , this) );

   390         }

   391     else

   392         {

   393         // Make Indicator Pane visible again and hide the ZoomPane

   394         iZoomPane->MakeVisible( EFalse, ETrue );

   395         

   396         // background needs redrawing behind zoom pane

   397         iRedrawPaneBackground = ETrue;

   398         }

   399     PRINT(_L("Camera <= CCamPreCaptureContainerBase::ZoomTimerTick")); 

   400     }

   401 

   402 // ----------------------------------------------------

   403 // CCamPreCaptureContainerBase::OfferKeyEventL

   404 // Handles this application view's command keys. Forwards other

   405 // keys to child control(s).

   406 // ----------------------------------------------------

   407 //

   408 TKeyResponse 

   409 CCamPreCaptureContainerBase::OfferKeyEventL( const TKeyEvent& aKeyEvent,

   410                                                    TEventCode aType )

   411     {         

   412     PRINT2( _L("Camera => CCamPreCaptureContainerBase::OfferKeyEventL type %d) scan code (%d)"), aType, aKeyEvent.iScanCode )

   413 

   414 #ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT

   415     // Log event only if this is the first capture key press and we are in correct state

   416     TCamCaptureOperation operation = iController.CurrentOperation();

   417 

   418     TBool isCaptureKeyForUs  = (IsCaptureKeyL( aKeyEvent, aType )

   419             && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );

   420 

   421     TBool isOperationStateOk = (ECamNoOperation == operation);

   422     if( isCaptureKeyForUs && isOperationStateOk )

   423         { 

   424         PERF_EVENT_START_L1( EPerfEventKeyToCapture );  

   425         }

   426 #endif      

   427 

   428     TBool isCaptureKeyForSymbTrace  = (IsCaptureKeyL( aKeyEvent, aType )

   429             && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );

   430     if( isCaptureKeyForSymbTrace )

   431         {

   432         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL Symbian Traces Active") );

   433         OstTrace0( CAMERAAPP_PERFORMANCE, DUP7_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

   434         OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_CAPTURE_START 1" ); //CCORAPP_CAPTURE_START_START

   435         if ( iFocusState != EFocusStateFocusing )

   436             {

   437             OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );   //CCORAPP_SHOT_TO_SNAPSHOT_START

   438             OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );  //CCORAPP_PRI_SHOT_TO_SNAPSHOT_START

   439             OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SAVE 1" );  //CCORAPP_PRI_SHOT_TO_SAVE_START

   440             OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SHOT 1" );  //CCORAPP_PRI_SHOT_TO_SHOT_START

   441             OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_STILL 1" ); //CCORAPP_SHOT_TO_STILL_START

   442             OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SERIAL_SHOOTING 1" );   //CCORAPP_PRI_SERIAL_SHOOTING_START

   443             }

   444         }

   445 

   446     iController.StartIdleTimer();

   447     if( aType == EEventKeyUp )

   448         {

   449         iController.SetDemandKeyRelease( EFalse ); 

   450         }

   451 

   452     CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

   453 	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer) );

   454     if ( appUi->CheckCourtesyKeyEventL( aKeyEvent, aType, ETrue ) == EKeyWasConsumed )

   455         {

   456         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL courtesy key") );

   457         return EKeyWasConsumed;

   458         }

   459 

   460     // If a control has the focus, give it the first opportunity to

   461     // process the key event

   462 

   463     if( iActivePalette 

   464             && iActivePalette->CoeControl()

   465             && iActivePalette->CoeControl()->OfferKeyEventL(aKeyEvent,aType) == EKeyWasConsumed )

   466         {

   467         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL AP consumed") );

   468         return EKeyWasConsumed;

   469         }

   470 

   471     // The key press has not been handled by a visible control

   472     // so will be processed by the container.

   473 

   474     // Handle Zoom in key if we are not saving video

   475     PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL B") )

   476     if ( IsZoomKeyL( aKeyEvent, aType ) 

   477             && ECamCompleting != iController.CurrentOperation() 

   478             && !iController.CurrentlySavingVideo()

   479             && !appUi->IsSecondCameraEnabled() )

   480         {       

   481         // Offer the key event to the zoom pane/model

   482         TKeyResponse resp = iZoomPane->OfferKeyEventL( aKeyEvent, aType );

   483 

   484         // If it was consumed, we need to keep the zoom pane visible

   485         if ( resp == EKeyWasConsumed )

   486             {

   487             ShowZoomPaneWithTimer();

   488             }

   489         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Zoom key") );    

   490         return resp;

   491         }

   492 

   493     else if ( EEventKey == aType

   494             && EKeyOK    == aKeyEvent.iCode

   495             && 0         == aKeyEvent.iRepeats )

   496         {

   497         TBool MSKCapture(EFalse);

   498         if ( !appUi->IsToolBarVisible() && aKeyEvent.iScanCode == EStdKeyDevice3 )

   499             {

   500             MSKCapture = ETrue;

   501             }

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

   503                 && !MSKCapture )

   504             {

   505             // AP needs to handle this

   506             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Ok key") );    

   507             return EKeyWasNotConsumed;

   508             }

   509         }

   510 

   511     // Handle right and left navi keys. 

   512     // Each product defines the behaviour that is mapped to these keys.        

   513     else if ( EEventKey == aType

   514             && ( EStdKeyRightArrow == aKeyEvent.iScanCode

   515                     || EStdKeyLeftArrow  == aKeyEvent.iScanCode ) )

   516         {

   517         if ( HandleLeftRightNaviKeyL( aKeyEvent, aType ) == EKeyWasConsumed )

   518             {

   519             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL left/right navi") );    

   520             return EKeyWasConsumed;

   521             }

   522         }

   523 

   524     else

   525         {

   526         // empty else statement to remove LINT error

   527         }

   528 

   529     TBool captureKey = IsCaptureKeyL( aKeyEvent, aType );

   530 

   531     // Stop any zooming activity if capture key detected

   532     if ( captureKey )

   533         {

   534         CCamZoomPane* zoom_pane = appUi->ZoomPane();

   535 

   536         if ( zoom_pane )

   537             {

   538             PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL calling StopZoom()") );

   539             zoom_pane->StopZoom();

   540             }

   541         }

   542     TBool viewFinderRunning = iReceivedVfFrame;

   543     if ( iController.UiConfigManagerPtr() &&

   544            ( iController.UiConfigManagerPtr()->

   545                IsDSAViewFinderSupported( ETrue ) &&

   546                !appUi->IsSecondCameraEnabled() ) ||

   547            ( iController.UiConfigManagerPtr()->

   548                IsDSAViewFinderSupported( EFalse ) &&

   549                appUi->IsSecondCameraEnabled() ) )

   550         {

   551         viewFinderRunning = appUi->IsDirectViewfinderActive();

   552         }

   553 

   554     TBool shutterKey = IsShutterKeyL( aKeyEvent, aType );

   555     TBool interruptKey = captureKey;

   556     if ( !appUi->IsSecondCameraEnabled() &&

   557             iController.UiConfigManagerPtr() && 

   558             iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

   559         {

   560         interruptKey = shutterKey;

   561         }

   562 

   563     if(iController.IsProcessingCapture() 

   564             // && appUi->CurrentCaptureMode() == ECamCaptureModeStill 

   565             && ECamControllerImage == iController.CurrentMode()

   566             && EEventKeyDown == aType

   567             && interruptKey

   568             && appUi->ShowPostCaptureView()

   569             && !appUi->IsBurstEnabled() 

   570             && !appUi->SelfTimerEnabled()) 

   571         {

   572         iController.SetCaptureKeyPressedWhileImageSaving(ETrue);

   573         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL 2nd press of capturekey") )

   574         return EKeyWasConsumed;

   575 

   576         }

   577     // Check if the key is a shutter key and...

   578     if ( shutterKey && viewFinderRunning )

   579         {

   580         if ( EKeyWasConsumed == HandleShutterKeyEventL( aKeyEvent, aType ) )

   581             {

   582             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL shutter key") );    

   583             return EKeyWasConsumed;

   584             }

   585         }

   586     else if ( captureKey             // Capture key event...

   587             && EEventKeyDown == aType // ...it's a key down event and

   588             && viewFinderRunning     // ...the viewfinder is running

   589             && !iController.Busy()    // CamCameraController is not busy.

   590             && !iController.IsDemandKeyRelease() ) // ...and no need to wait key up 

   591         {

   592         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. [KEYS] capture key down") )

   593         if ( HandleCaptureKeyEventL( aKeyEvent ) == EKeyWasConsumed )

   594             {

   595             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL capture key handled") )

   596             return EKeyWasConsumed;

   597             }

   598         }         

   599     else if ( captureKey && aType == EEventKeyUp )

   600         {      

   601         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. [KEYS] capture key up") )

   602         if ( iController.SequenceCaptureInProgress()  // actively capturing or   

   603                 || appUi->IsBurstEnabled()                  // burst is enabled (for if focusing)

   604         )

   605             {

   606             if ( appUi->CurrentBurstMode() == ECamImageCaptureTimeLapse )

   607                 {

   608                 PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. timelapse mode, update CBA") )

   609                 // if this is a timelapse capture then set the softkeys to blank/cancel.

   610                 // The next shutter press will stop the capture.

   611                 TRAP_IGNORE( static_cast<CCamPreCaptureViewBase*>( &iView )->UpdateCbaL() );

   612                 }

   613             else

   614                 {

   615                 if ( !appUi->SelfTimerEnabled() )

   616                     {

   617 

   618                     if ( !iController.AllSnapshotsReceived() && (iController.CurrentCapturedCount() >= 1) )

   619                         {   		

   620                         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. burst mode, soft stop burst..") )

   621                         // burst ongoing, still receiving snapshots, end it as soon as possible.

   622                         iController.SetKeyUp( ETrue );

   623                         iController.SoftStopBurstL();

   624                         }

   625                     else 

   626                         {

   627                         // ignore keypress, all snapshot received and processing image data

   628                         // processing only stopped from softkey

   629                         }

   630                     }

   631                 }

   632 

   633             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL .. capture key up handled") )

   634             return EKeyWasConsumed;

   635             }

   636         }

   637     else 

   638         {

   639         // remove Lint warning                

   640         }

   641 

   642     TKeyResponse response = CCamContainerBase::OfferKeyEventL( aKeyEvent, aType );

   643 

   644     PRINT1( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL, return %d"), response )

   645     return response;

   646     }

   647 

   648 

   649 // ---------------------------------------------------------

   650 // CCamPreCaptureContainerBase::HandleControllerEventL

   651 // Handles zoom events from the Controller

   652 // ---------------------------------------------------------

   653 //

   654 void 

   655 CCamPreCaptureContainerBase

   656 ::HandleControllerEventL( TCamControllerEvent aEvent, 

   657                           TInt                /*aError*/ )

   658   {

   659   PRINT1(_L("Camera => CCamPreCaptureContainerBase::HandleControllerEventL(%d)"), aEvent );

   660 

   661   __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );

   662   CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

   663 

   664   switch( aEvent )

   665     {

   666     // ---------------------------------------------------

   667     case ECamEventSaveCancelled:

   668       {

   669       // clear the side pane after saving images dialog is dismissed

   670       ForceSideZoomPaneDraw();

   671       break;

   672       }

   673     // ---------------------------------------------------

   674     case ECamEventCameraChanged:

   675       {      

   676       SetResolutionIndicator();

   677       break;

   678       }

   679 

   680     // ---------------------------------------------------

   681     case ECamEventCounterUpdated:

   682       {

   683       if ( iController.UiConfigManagerPtr() &&

   684            iController.UiConfigManagerPtr()->IsDSAViewFinderSupported() )

   685           {

   686           if( iPaneInUse == ECamPaneProgress && appUi && appUi->IsDirectViewfinderActive() )

   687             {

   688             ActivateGc();

   689             CWindowGc& gc = SystemGc();

   690             iNaviProgressBarControl->DrawProgressBar( gc );

   691             DeactivateGc();

   692             }  

   693           else if ( iPaneInUse == ECamPaneCounter && iController.SequenceCaptureInProgress() )

   694             {

   695             DrawDeferred();

   696             }

   697           else

   698             {

   699             // Lint

   700             }

   701           }

   702       break;

   703       }

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

   705     case ECamEventOperationStateChanged:

   706       {

   707       if( iController.IsAppUiAvailable() && iController.UiConfigManagerPtr()

   708           && iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

   709         {

   710         // ReCheck if we have to draw the reticule.

   711         if ( ECamControllerImage == iController.CurrentMode() )

   712             {

   713             iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

   714             HandleOperationStateChangeEventL();

   715             }

   716        

   717         }

   718       break;

   719       }

   720     // ---------------------------------------------------

   721     case ECamEventExitRequested:

   722       {

   723       iShuttingDown = ETrue;                        

   724       break;

   725       }

   726     // ---------------------------------------------------

   727     case ECamEventRecordComplete:

   728       {

   729       iResolutionIndicators[iCurrentIndicator]->CancelOverridePosition();

   730       break;

   731       }    

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

   733     // Scene has changed

   734     case ECamEventSceneStateChanged:

   735       {

   736       PRINT(_L("Camera <> CCamPreCaptureContainerBase::HandleControllerEventL ECamEventSceneStateChanged"));

   737       if ( iController.UiConfigManagerPtr() && 

   738            iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

   739         {

   740         // Scene state has changed, re-check whether we should 

   741         // be showing the reticule

   742         iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

   743         }

   744       ResetVFGridVisibility();

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

   746       break;

   747       }

   748     // ---------------------------------------------------

   749     case ECamEventImageData:

   750         {

   751         UpdateBurstProcessingTextL( iController.CapturedImages(), iController.CurrentCapturedCount() );

   752         break;

   753         }

   754     // ---------------------------------------------------  

   755     case ECamEventSliderClosed:

   756         {

   757         //Do nothing

   758         }

   759 		break;

   760     // ---------------------------------------------------

   761     case ECamEventCaptureComplete:

   762         {

   763         if ( !appUi->IsSecondCameraEnabled() 

   764               && iController.CurrentMode() == ECamControllerImage )

   765             {

   766             DrawNow();

   767             }

   768         break;

   769         }

   770     // ---------------------------------------------------

   771     case ECamEventFaceTrackingStateChanged:

   772         {

   773         if( iController.UiConfigManagerPtr()

   774             && iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

   775             {

   776             // ReCheck if we have to draw the reticule.

   777             if ( ECamControllerImage == iController.CurrentMode() )

   778                 {

   779                 iPhotoSceneUsesReticule = 

   780                     !iController.CurrentSceneHasForcedFocus();

   781                 }

   782             }

   783         }

   784     default:

   785       {

   786       // Other events => no action.

   787       break;

   788       }

   789     // ---------------------------------------------------

   790     }

   791   PRINT(_L("Camera <= CCamPreCaptureContainerBase::HandleControllerEventL"));

   792   }

   793 

   794 // ---------------------------------------------------------

   795 // CCamPreCaptureContainerBase::HandleForegroundEvent

   796 // Handles change of app foreground state

   797 // ---------------------------------------------------------

   798 //

   799 void CCamPreCaptureContainerBase::HandleForegroundEventL( TBool aForeground )

   800     {

   801     PRINT1( _L( "Camera => CCamPreCaptureContainerBase::HandleForegroundEventL %d" ), aForeground );            

   802     if ( aForeground )

   803         {

   804 /*#ifndef __WINS__

   805         CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

   806         if( appUi->IsInCallSend() )

   807             {

   808             // force side pane to update

   809             appUi->SidePane()->SetInitialState();

   810             }

   811 #endif*/      

   812         // Check if we are on a non-standard zoom level.  Also checks if previous 

   813         // view was PostCapture or settings, if so, we dont want to show the zoom

   814         // pane either 

   815         if ( iZoomPane->ZoomValue() != 0  &&

   816              !iZoomPane->IsResetPending() &&

   817              iPrevViewId != ECamViewIdStillPostCapture &&

   818              iPrevViewId != ECamViewIdVideoPostCapture &&

   819              iPrevViewId != ECamViewIdPhotoSettings &&

   820              iPrevViewId != ECamViewIdVideoSettings )

   821             {

   822             // If we have moved to the foreground and need to show the zoom level.

   823             ShowZoomPaneWithTimer();

   824             }            

   825 

   826         ResetVFGridVisibility();

   827         }

   828     else    

   829         {

   830         iReceivedVfFrame = EFalse;

   831 

   832         // Cancel timer if we're losing focus

   833         iZoomTimer->Cancel();  

   834         

   835         if ( !iShuttingDown )

   836             {

   837             iSidePane->MakeVisible( ETrue );

   838             iZoomPane->MakeVisible( EFalse, EFalse );

   839             

   840             // Will stop any ongoing zoom

   841             iZoomPane->HandleForegroundEvent( aForeground );

   842             }

   843         

   844         // Update the view ID for when we come back.

   845         TCamAppViewIds viewId = static_cast<TCamAppViewIds>( iView.Id().iUid );

   846         SetPreviousViewId( viewId );      

   847         }

   848     PRINT( _L( "Camera <= CCamPreCaptureContainerBase::HandleForegroundEventL" ) );        

   849     }

   850 

   851 

   852 // -----------------------------------------------------------------------------

   853 // HandleAppEvent <<virtual>>

   854 //

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

   856 //

   857 void 

   858 CCamPreCaptureContainerBase::HandleAppEvent( const TCamAppEvent& aEvent )

   859   {

   860   PRINT( _L("Camera => CCamPreCaptureContainerBase::HandleAppEvent") );

   861 

   862   switch( aEvent )

   863     {

   864     case ECamAppEventFocusGained:

   865       {

   866       // Clear non-fading flag. It may have been set when showing a note

   867       // in CCamAppUi::ShowErrorNoteL().

   868 

   869       CEikMenuBar* menuBar = iView.MenuBar();

   870       TBool menuOpened( EFalse );

   871       if ( menuBar )

   872           {

   873           menuOpened = menuBar->IsDisplayed();

   874           }

   875       

   876       RDrawableWindow* window = DrawableWindow();

   877       if ( window && !menuOpened )

   878           {

   879           window->SetNonFading( EFalse );

   880           }

   881 

   882       if( iBatteryPaneController )

   883         iBatteryPaneController->Pause( EFalse );

   884       break;

   885       }

   886     case ECamAppEventFocusLost:

   887       {

   888       if( iBatteryPaneController )

   889         iBatteryPaneController->Pause( ETrue );

   890       break;

   891       }

   892     default:

   893       {

   894       break;

   895       }

   896     }

   897 

   898   PRINT( _L("Camera <= CCamPreCaptureContainerBase::HandleAppEvent") );

   899   }

   900 

   901 

   902 // ----------------------------------------------------

   903 // CCamPreCaptureContainerBase::MakeVisible

   904 // Handles a change to the controls visibility

   905 // ----------------------------------------------------

   906 //

   907 void CCamPreCaptureContainerBase::MakeVisible( TBool aVisible )

   908   {

   909   PRINT1( _L("Camera => CCamPreCaptureContainerBase::MakeVisible, visible:%d"), aVisible );

   910 

   911   CCamContainerBase::MakeVisible( aVisible );

   912 

   913   PRINT ( _L("Camera <= CCamPreCaptureContainerBase::MakeVisible") );

   914   }

   915 

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

   917 // CCamPreCaptureContainerBase::Draw

   918 // Draw control

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

   920 //

   921 void 

   922 CCamPreCaptureContainerBase::Draw( const TRect& /*aRect*/ ) const

   923    {

   924    PRINT( _L( "Camera => CCamPreCaptureContainerBase::Draw" ) );    

   925    

   926    CWindowGc& gc = SystemGc(); 

   927    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

   928   

   929    // Is direct viewfinding active

   930     TBool directVf = appUi ? appUi->IsDirectViewfinderActive() : EFalse;

   931                  

   932    // Using bitmap viewfinding and a frame is available

   933    TBool bitmapFrame = !directVf && iReceivedVfFrame && iViewFinderBackup;

   934 

   935    if( iCamOrientation != ECamOrientationCamcorder && 

   936        iCamOrientation != ECamOrientationCamcorderLeft && 

   937     !( iController.UiConfigManagerPtr() && 

   938        iController.IsDirectScreenVFSupported( EFalse ) && 

   939        iCamOrientation == ECamOrientationPortrait ) )

   940       { 

   941       // Using secondary camera 

   942       }

   943    else  if( !bitmapFrame )  

   944        {  

   945        // Using primary camera and direct viewfinding is active, there's no bitmap

   946        // viewfinder frame available, or the frame doesn't cover whole screen

   947        // => Paint the background with background color / color key

   948                             

   949        gc.SetPenStyle( CGraphicsContext::ENullPen );    

   950     

   951        if( iController.UiConfigManagerPtr() && directVf )

   952            {    

   953            gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

   954            gc.SetBrushColor( TRgb::Color16MA( 0 ) );

   955            }

   956        else

   957            {

   958            // Use the background color

   959            gc.SetBrushColor( TRgb( KCamPrecaptureBgColor ) );   

   960            }

   961             

   962        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

   963        gc.DrawRect( Rect() );          

   964        }

   965       else

   966       	{

   967       	}

   968    if ( bitmapFrame )

   969       {

   970       // Draw the current bitmap viewfinder frame  

   971       DrawFrameNow( gc, iViewFinderBackup );

   972       }          

   973 

   974    gc.Reset();        

   975    if( directVf 

   976    && !iController.IsViewFinding() )

   977        {

   978        return;

   979        }

   980    else

   981        {

   982        //Do nothing

   983        }

   984    DrawScreenFurniture( gc );

   985    DrawNaviControls( gc );

   986    PRINT( _L( "Camera <= CCamPreCaptureContainerBase::Draw" ) );        

   987    }

   988 

   989 

   990 

   991 

   992 

   993 

   994 // <CAMERAAPP_CAPI_V2_MIGRATION>

   995 // ===========================================================================

   996 // From MCamCameraObserver

   997 

   998 // ---------------------------------------------------------------------------

   999 // virtual HandleCameraEventL

  1000 // ---------------------------------------------------------------------------

  1001 //

  1002 void 

  1003 CCamPreCaptureContainerBase

  1004 ::HandleCameraEventL( TInt              aStatus, 

  1005                       TCamCameraEventId aEventId, 

  1006                       TAny*             aEventData /*= NULL*/ )

  1007   {

  1008   switch( aEventId )

  1009     {

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

  1011     case ECamCameraEventVfStop:

  1012     case ECamCameraEventVfRelease:

  1013       // old vf frame being shown when returning from background.

  1014        if ( ECamActiveCameraSecondary ==  iController.ActiveCamera() )

  1015         {     

  1016         ActivateGc();

  1017         CWindowGc& gc = SystemGc();	      

  1018         gc.SetBrushColor( KRgbBlack );

  1019         gc.Clear( Rect() );

  1020         DeactivateGc();		

  1021         }    		

  1022       iReceivedVfFrame = EFalse;

  1023       break;

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

  1025     case ECamCameraEventVfFrameReady:

  1026       {

  1027       PRINT_FRQ( _L("Camera => CCamPreCaptureContainerBase::HandleCameraEventL: case ECamCameraEventVfFrameReady") );

  1028       if( KErrNone == aStatus )

  1029         {

  1030         // Mark first frame arrived.

  1031         iReceivedVfFrame = ETrue;

  1032     

  1033         // If status is ok, we should always receive a bitmap.

  1034         CFbsBitmap* frame = static_cast<CFbsBitmap*>( aEventData );    

  1035         __ASSERT_ALWAYS( frame, CamPanic( ECamPanicNullPointer ) );

  1036     

  1037         // Make a duplicate copy of the vfFrame in order to show

  1038         // it later on where needed.

  1039         if ( iViewFinderBackup )

  1040           {

  1041           iViewFinderBackup->Reset();

  1042           }

  1043         else

  1044           {

  1045           TRAP_IGNORE ( iViewFinderBackup = new (ELeave) CFbsBitmap() );

  1046           }

  1047 

  1048         if ( iViewFinderBackup )

  1049           {

  1050           TInt dupeError = iViewFinderBackup->Duplicate(frame->Handle());

  1051           if ( dupeError )

  1052             {

  1053             iViewFinderBackup->Reset();

  1054             delete iViewFinderBackup;

  1055             iViewFinderBackup = NULL;

  1056             }

  1057           }

  1058 

  1059         // Do a redraw.

  1060         ActivateGc();

  1061         CWindowGc& gc = SystemGc();

  1062 

  1063         PRINT_FRQ4( _L("ECamCameraEventVfFrameReady - rect is %d,%d - %d,%d"), Rect().iTl.iX, Rect().iTl.iY, Rect().iBr.iX, Rect().iBr.iY ) 

  1064 

  1065       	if( ECamCapturing == iController.CurrentVideoOperation() )

  1066       	  {   

  1067           // -----------------------------------------

  1068           // Draw all content directly to system gc

  1069       	  PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase::ShowViewFinderFrame without offscreen bitmap") )   

  1070       	  RWindow window = Window();

  1071       	  window.Invalidate( Rect() );

  1072       	  window.BeginRedraw( Rect() );    

  1073       		DrawToContext(gc, frame);

  1074       		window.EndRedraw();

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

  1076       	  }

  1077         else

  1078           { 

  1079           if( iBitmapGc )

  1080             {

  1081             // -----------------------------------------

  1082             // Draw all content to the offscreen bitmap

  1083             DrawToContext( *iBitmapGc, frame );

  1084       

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

  1086             // Draw the offscreen bitmap to screen

  1087             RWindow window = Window();

  1088             window.Invalidate( Rect() );

  1089             window.BeginRedraw( Rect() );

  1090             gc.BitBlt( TPoint( 0,0 ), iOffScreenBitmap );

  1091             window.EndRedraw();

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

  1093             }

  1094           else

  1095             {

  1096             PRINT_FRQ( _L("Camera <> CCamPreCaptureContainerBase: iBitmapGc == NULL"));

  1097             }

  1098           }

  1099         DeactivateGc();

  1100         PRINT_FRQ( _L("Camera <= CCamPreCaptureContainerBase::HandleCameraEventL") );

  1101         }

  1102       break;

  1103       }

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

  1105     case ECamCameraEventSsReady:

  1106       {

  1107       PRINT( _L( "Camera => CCamPreCaptureContainerBase::HandleCameraEventL: case ECamCameraEventSsReady" ) );  

  1108 

  1109       CCamAppUi* appUi = static_cast<CCamAppUi*>(CEikonEnv::Static()->AppUi());

  1110 

  1111 	  if( KErrNone == aStatus

  1112        && ( ECamImageCaptureTimeLapse == appUi->CurrentBurstMode() ||

  1113             ECamImageCaptureBurst     == appUi->CurrentBurstMode() ) )

  1114         {

  1115         // In timelapse mode, convert snapshot event to vf frame event

  1116         PRINT( _L( "In timelapse mode, converting event to ECamCameraEventVfFrameReady" ) );

  1117         HandleCameraEventL( aStatus, ECamCameraEventVfFrameReady, aEventData );  

  1118         }

  1119       else if( KErrNone == aStatus && 

  1120                ECamControllerImage == iController.CurrentMode() &&

  1121                appUi->ShowPostCaptureView() )

  1122         {

  1123         // use mask mode to draw battery pane when showing snapshot

  1124         // and hide side pane altogether ( as there is no feasible way to draw

  1125         // it properly on top of the snapshot because of the current CCamIndicator implementation)

  1126         iSidePane->MakeVisible( EFalse );

  1127         // also hide zoom pane at the same time

  1128         iZoomPane->MakeVisible( EFalse, EFalse );

  1129         

  1130         OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_HANDLECAMERAEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 0" ); //CCORAPP_PRI_SHOT_TO_SNAPSHOT_END

  1131         OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_HANDLECAMERAEVENTL, "e_CAM_APP_SNAPSHOT_DRAW 1" );   //CCORAPP_SNAPSHOT_DRAW_START

  1132         HandleCameraEventL( aStatus, ECamCameraEventVfFrameReady, aEventData );

  1133         OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_HANDLECAMERAEVENTL, "e_CAM_APP_SNAPSHOT_DRAW 0" );   //CCORAPP_SNAPSHOT_DRAW_END

  1134         }