MCL/sf/app/camera: comparison camerauis/cameraapp/generic/src/cameracontroller/camcameracontroller.cpp

equal deleted inserted replaced

-:792dfc98fb3b
+:8c55c525d5d7
 /*
 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 // Custom interfaces
 #include <ECamOrientationCustomInterface2.h>
 #include <ECamUIOrientationOverrideCustomAPI.h>
 #include <ecamfacetrackingcustomapi.h>
 #include <akntoolbar.h>
 // -------------------------------------
 // Own
 #include "camcameracontroller.pan"
 #include "camlogging.h"
 #include "cambuffershare.h"
 #include "cambuffersharecleanup.h"
 #include "cambuffercleanup.h"
 #include "cambuffer.h"
 #include "camsnapshotprovider.h"
 #include "camimageencoder.h"
 #include "mcamsettingprovider.h"
 #include "CameraUiConfigManager.h"
 #include "CamViewBase.h"
 #include "CamPanic.h"
 // ===========================================================================
 // Local constants
 const TInt KIveRecoveryCountMax = 2;
 typedef CCamera::CCameraAdvancedSettings CAS;
 typedef CCamera::CCameraImageProcessing  CIP;
 namespace NCamCameraController
 {
 static const TInt               KPrimaryCameraIndex         =  0;
 //static const TInt               KSecondaryCameraIndex       =  1;
 static const TInt               KInvalidCameraIndex         = -1;
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 //  static const TInt             KCameraDisplayIndex         = 0;
 #endif
 #ifdef CAMERAAPP_CAPI_V2
 static const TInt             KCameraClientPriority       = 100; // -100...100
 #endif
 static const TInt               KCamCallBackPriority        = EPriorityHigh;
 static const TInt               KCamSequenceGranularity     =  2;
 static const TInt               KResolutionArrayGranularity =  8;
 #ifdef CAMERAAPP_CAPI_V2_ADV
 static const TInt             KAdvArrayGranularity        =  5;
 #endif
 static const CCamera::TFormat   KCamJpegAlternativeFormat1  = CCamera::EFormatFbsBitmapColor16M;
 static const CCamera::TFormat   KCamJpegAlternativeFormat2  = CCamera::EFormatFbsBitmapColor64K;
 static const TInt             KCamReserveTryAgainMaxCount     = 50;
 static const TInt             KCamReserveTryAgainWaitInterval = 50000; // 50 milliseconds
 #ifdef _DEBUG
 _LIT( KCamDriveModeNameBurst,   "EDriveModeBurst"      );
 _LIT( KCamDriveModeNameSingle,  "EDriveModeSingleShot" );
 #define CAMERAAPP_PERF_CONTROLLER_STARTNEW( AAA, BBB )
 #define CAMERAAPP_PERF_CONTROLLER_STOP( AAA )
 #define CAMERAAPP_PERF_CONTROLLER_STOP_ONCE( AAA, BBB )
 #endif // CAMERAAPP_PERFORMANCE_CONTROLLER
 // Helper methods
 #include "camflagutility.inl"
 #include "campointerutility.inl"
 namespace NCamCameraController
 {
 /*
 inline void SetFalse( TAny* aTBool )
 {
 TBool* boolean = static_cast<TBool*>( aTBool );
 if( boolean )
 *boolean = EFalse;
 }
 */
 inline void SetNotBusy( TAny* aTUint )
 {
 TUint* flags = static_cast<TUint*>( aTUint );
 if( flags )
 *flags = ECamBusyOff;
 };
 inline void ReleaseAndNull( MCameraBuffer*& aBuffer )
 {
 if( aBuffer )
 {
 aBuffer->Release();
 }
 };
 #ifdef CAMERAAPP_CAPI_V2_ADV
 inline void ResetInfo( TAny* aInfo )
 {
 TCamAdvancedSettingInfo* info =
 static_cast<TCamAdvancedSettingInfo*>( aInfo );
 if( info )
 {
 info->Reset();
 }
 };
 inline const TDesC& DriveModeName( TInt aMode )
 {
 iSnapshotFormat         = CCamera::EFormatFbsBitmapColor16M;
 iSnapshotAspectMaintain = EFalse;
 if( !aPreserveBusyFlag )
 {
 iBusy = ECamBusyOff;
 }
 }
 // ---------------------------------------------------------------------------
 // PrintInfo
 // ---------------------------------------------------------------------------
 //
 void
 TCamControllerInfo::PrintInfo() const
 {
 PRINT ( _L("Camera <> --------------------------------------------------") );
 PRINT ( _L("Camera <> TCamControllerInfo")                                 );
 PRINT ( _L("Camera <> ")                                                   );
 TCamCameraResolutionSupport::~TCamCameraResolutionSupport()
 {
 iResolutions.Close();
 }
 void
 TCamCameraResolutionSupport::Reset()
 {
 iForCameraIndex  = KInvalidCameraIndex;
 iForCameraFormat = -1;
 iResolutions.Reset();
 {
 iEvStepsSupport.Close();
 iIsoRatesSupport.Close();
 }
 void
 TCamAdvancedSettingInfo::Reset()
 {
 iForCameraIndex = KInvalidCameraIndex;
 iEvModesSupport = 0;
 // ---------------------------------------------------------------------------
 // PrintInfo
 // ---------------------------------------------------------------------------
 //
 void
 TCamAdvancedSettingInfo::PrintInfo() const
 {
 #ifdef _DEBUG
 PRINT ( _L("Camera <> --------------------------------------------------") );
 PRINT ( _L("Camera <> Value infos:")                                       );
 for( TInt i = 0; i < iEvStepsSupport.Count(); i++ )
 {
 PRINT2( _L("Camera <> step[%3d]: %4d"), i, iEvStepsSupport[i] );
 }
 PRINT ( _L("Camera <> --------------------------------------------------") );
 PRINT1( _L("Camera <> Advanced EV modes support : %016b"), iEvModesSupport                    );
 PRINT1( _L("Camera <> EExposureAuto             : %016b"), CCamera::EExposureAuto             );
 PRINT1( _L("Camera <> EExposureNight            : %016b"), CCamera::EExposureNight            );
 PRINT1( _L("Camera <> EExposureBacklight        : %016b"), CCamera::EExposureBacklight        );
 PRINT1( _L("Camera <> EExposureCenter           : %016b"), CCamera::EExposureCenter           );
 PRINT1( _L("Camera <> EEffectVivid          : %016b"), CIP::EEffectVivid           );
 PRINT1( _L("Camera <> EEffectLowSharpening  : %016b"), CIP::EEffectLowSharpening   );
 PRINT ( _L("Camera <> --------------------------------------------------") );
 #endif // CAMERAAPP_CAPI_V2_IP
 PRINT ( _L("Camera <> --------------------------------------------------") );
 PRINT1( _L("Camera <> Stabilization modes support      : %016b"), iStabilizationModeSupport           );
 PRINT1( _L("Camera <>   EStabilizationModeOff          : %016b"), CAS::EStabilizationModeOff          );
 PRINT1( _L("Camera <>   EStabilizationModeHorizontal   : %016b"), CAS::EStabilizationModeHorizontal   );
 PRINT1( _L("Camera <>   EStabilizationModeVertical     : %016b"), CAS::EStabilizationModeVertical     );
 PRINT1( _L("Camera <>   EStabilizationModeRotation     : %016b"), CAS::EStabilizationModeRotation     );
 PRINT1( _L("Camera <> Stabilization complexity support : %016b"), iStabilizationComplexitySupport     );
 PRINT1( _L("Camera <>   EStabilizationComplexityAuto   : %016b"), CAS::EStabilizationComplexityAuto   );
 PRINT1( _L("Camera <>   EStabilizationComplexityLow    : %016b"), CAS::EStabilizationComplexityLow    );
 PRINT1( _L("Camera <>   EStabilizationComplexityMedium : %016b"), CAS::EStabilizationComplexityMedium );
 PRINT1( _L("Camera <>   EStabilizationComplexityHigh   : %016b"), CAS::EStabilizationComplexityHigh   );
 PRINT ( _L("Camera <> --------------------------------------------------") );
 #endif // _DEBUG
 }
 #endif // CAMERAAPP_CAPI_V2_ADV
 // ---------------------------------------------------------------------------
 // static 2-phase constructor
 // ---------------------------------------------------------------------------
 //
 CCamCameraController*
 CCamCameraController::NewL( MCamSettingProvider& aProvider,
 CCamAppController& aAppController,
 TInt aCameraIndex /*= 0*/ )
 {
 CCamCameraController* self
 = new (ELeave) CCamCameraController( aProvider, aAppController );
 CleanupStack::PushL( self );
 self->ConstructL( aCameraIndex );
 CleanupStack::Pop( self );
 return self;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 {
 PRINT( _L("Camera => ~CCamCameraController") );
 #ifdef CAMERAAPP_FLASH_SIMULATOR
 delete iFlashSimulator;
 #endif
 #ifdef CAMERAAPP_PERFORMANCE_CONTROLLER
 delete iPerformanceLogger;
 #endif // CAMERAAPP_PERFORMANCE_CONTROLLER
 delete iIdle;
 iSettingArray.Close();
 // Remove all observers.
 // We do not want to broadcast events anymore in this phase.
 iObservers.Reset();
 ClearRequestQueue();
 ClearSettingQueue();
 PRINT( _L("Camera <> CCamCameraController: release current camera..") );
 // Release and null CCamera related objects.
 ReleaseCurrentCamera();
 PRINT( _L("Camera <> CCamCameraController: ..done") );
 delete iActive;
 iObservers.Close();
 iObserverInterests.Close();
 // ---------------------------------------------------------------------------
 // HandleEvent
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::HandleEvent( const TECAMEvent& aEvent )
 {
 // TUid iEventType;
 // TInt iErrorCode;
 PRINT2( _L("Camera => CCamCameraController::HandleEvent, event uid(0x%08x) error(%d)"),
 aEvent.iEventType.iUid,
 aEvent.iErrorCode );
 // If we are getting zoom event while saving video,
 // we must not handle the event
 TInt uidValue( aEvent.iEventType.iUid );
 if ( uidValue == KUidECamEventCameraSettingDigitalZoomUidValue
 && IsFlagOn( iInfo.iBusy, ECamBusySingle ) )
 {
 return;
 }
 {
 HandleReserveLostEvent( aEvent.iErrorCode );
 }
 // -------------------------------------------------------
 else if( !(IsFlagOn( iInfo.iState , ECamPowerOn )))
 {
 //If camera is in background then all the rest events will be ignored. Should return without leaving
 return;
 }
 // -------------------------------------------------------
 else if( aEvent.iEventType == KUidECamEventCameraSnapshot )
 {
 HandleSnapshotEvent( aEvent.iErrorCode );
 }
 // -------------------------------------------------------
 else if( aEvent.iEventType == KUidECamEventCameraSettingsOptimalFocus
 || aEvent.iEventType == KUidECamEventCameraSettingAutoFocusType2 )
 {
 HandleAutoFocusEvent( aEvent.iErrorCode, aEvent.iEventType );
 }
 // -------------------------------------------------------
 else
 {
 #ifdef CAMERAAPP_CAPI_V2_ADV
 TInt uidValue( aEvent.iEventType.iUid );
 switch( uidValue )
 case KUidECamEventCameraSettingOpticalZoomUidValue:
 case KUidECamEventImageProcessingAdjustSharpnessUidValue:
 case KUidECamEventImageProcessingEffectUidValue:
 case KUidECamEventSettingsStabilizationAlgorithmComplexityUidValue:
 {
 TCamCameraSettingId id =
 CCamSettingConversion::Map2CameraSetting( uidValue );
 HandleCallbackEvent( aEvent.iErrorCode,
 ECamCameraEventSettingsSingle,
 ECamCameraEventClassSettings,
 &id );
 break;
 }
 // -------------------------------
 // Flash status info
 break;
 case KUidECamEventFlashNotReadyUidValue:
 HandleFlashStatusEvent( aEvent.iErrorCode, ECamCameraEventFlashNotReady );
 break;
 // -------------------------------
 default:
 break;
 // -------------------------------
 }
 #endif // CAMERAAPP_CAPI_V2_ADV
 }
 // ---------------------------------------------------------------------------
 // ViewFinderReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ViewFinderReady( MCameraBuffer& aCameraBuffer, TInt aError )
 {
 HandleViewfinderEvent( &aCameraBuffer, aError );
 }
 // ---------------------------------------------------------------------------
 // ImageBufferReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ImageBufferReady( MCameraBuffer& aCameraBuffer, TInt aError )
 {
 HandleImageCaptureEvent( &aCameraBuffer, aError );
 }
 // ---------------------------------------------------------------------------
 // VideoBufferReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::VideoBufferReady( MCameraBuffer& aCameraBuffer, TInt aError )
 {
 if( KErrNone == aError )
 {
 aCameraBuffer.Release();
 // ---------------------------------------------------------------------------
 // ReserveComplete
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ReserveComplete( TInt aError )
 {
 HandleReserveGainEvent( aError );
 }
 // ---------------------------------------------------------------------------
 // PowerOnComplete
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::PowerOnComplete( TInt aError )
 {
 HandlePowerOnEvent( aError );
 }
 // ---------------------------------------------------------------------------
 // ViewFinderFrameReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ViewFinderFrameReady( CFbsBitmap& aFrame )
 {
 PRINT( _L("CamTest => CCamCameraController::ViewFinderFrameReady") );
 CCamBuffer* buffer = NULL;
 TRAPD( error, buffer = CCamBuffer::NewL( aFrame, NULL ) );
 // Releases buffer
 HandleViewfinderEvent( buffer, error );
 PRINT( _L("CamTest <= CCamCameraController::ViewFinderFrameReady") );
 }
 // ---------------------------------------------------------------------------
 // ImageReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ImageReady( CFbsBitmap* aBitmap,
 HBufC8*    aData,
 TInt       aError )
 {
 PRINT( _L("Camera => CCamCameraController::ImageReady") );
 CCamBuffer* buffer = NULL;
 // If no error so far, wrap the data to MCameraBuffer compatible wrapper.
 // New API provides these buffers already from CCamera callbacks.
 if( KErrNone == aError )
 {
 TRAP( aError,
 // ---------------------------------------------------------------------------
 // FrameBufferReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::FrameBufferReady( MFrameBuffer* aFrameBuffer,
 TInt          /*aError*/ )
 {
 // Release the buffer if one is provided to make sure
 // CCamera can reuse it.
 if( aFrameBuffer )
 // ---------------------------------------------------------------------------
 // McaeoInitComplete
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoInitComplete( TInt aError )
 {
 PRINT( _L("Camera => CCamCameraController::McaeoInitComplete") );
 // Only interested on this callback, if CCamera duplicate
 // cannot be used with CAE. Otherwise we follow this event through
 // ---------------------------------------------------------------------------
 // McaeoStillPrepareComplete
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoStillPrepareComplete( TInt /*aError*/ )
 {
 PRINT( _L("Camera =><= CCamCameraController::McaeoStillPrepareComplete, PANIC!") );
 // Still capture not done through CCaeEngine.
 __ASSERT_DEBUG( EFalse, Panic( ECamCameraControllerCaeUnsupported ) );
 }
 // ---------------------------------------------------------------------------
 // McaeoVideoPrepareComplete
 //
 // This method is called asynchronously after a call has been made to
 // CCaeEngine::PrepareVideoRecordingL.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoVideoPrepareComplete( TInt aError )
 {
 PRINT( _L("Camera => CCamCameraController::McaeoVideoPrepareComplete") );
 #ifdef CAMERAAPP_CAE_ERR_SIMULATION
 HandleVideoEvent( ECamCameraEventVideoInit, aError );
 // DelayCallback( ECamCameraEventVideoInit, aError, 500000 );
 #else
 if( aError &&
 ( iIveCancel || ( !iIveSequenceActive && iIveRecoveryOngoing ) ) )
 // Return if error and recovering process has been started,
 // but this video prepare complete is not part of recovery
 // i.e. iIveSequenceActive is not active yet.
 {
 PRINT1( _L("Camera => CCamCameraController::McaeoVideoPrepareComplete - Ignore err %d"), aError );
 return;
 }
 HandleVideoEvent( ECamCameraEventVideoInit, aError );
 #endif // CAMERAAPP_CAE_ERR_SIMULATION
 PRINT( _L("Camera <= CCamCameraController::McaeoVideoPrepareComplete") );
 }
 // ---------------------------------------------------------------------------
 // McaeoViewFinderFrameReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoViewFinderFrameReady( CFbsBitmap& aFrame,
 TInt        aError )
 {
 PRINT( _L("Camera => CCamCameraController::McaeoViewFinderFrameReady") );
 CCamBuffer* buffer = NULL;
 if( KErrNone == aError )
 // ---------------------------------------------------------------------------
 // McaeoSnapImageReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoSnapImageReady( const CFbsBitmap& aBitmap,
 TInt        aError  )
 {
 PRINT1( _L("Camera => CCamCameraController::McaeoSnapImageReady, status: %d"), aError );
 //__ASSERT_DEBUG( EFalse, Panic( ECamCameraControllerCaeUnsupported ) );
 if(
 #ifdef CAMERAAPP_CAE_FIX
 ECamModeChangeInactive == iModeChange &&
 #endif
 IsFlagOn( iInfo.iState, ECamVideoOn )
 )
 {
 CAMERAAPP_PERF_CONTROLLER_STOP( ECamRequestSsStart );
 CFbsBitmap* copy( NULL );
 }
 NotifyObservers( aError,
 ECamCameraEventSsReady,
 ECamCameraEventClassSsData,
 copy );
 delete copy;
 copy = NULL;
 }
 PRINT( _L("Camera <= CCamCameraController::McaeoSnapImageReady") );
 }
 // ---------------------------------------------------------------------------
 // McaeoStillImageReady
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoStillImageReady( CFbsBitmap* /*aBitmap*/,
 HBufC8*     /*aData  */,
 TInt        /*aError */ )
 {
 // Still images are not captured through CCaeEngine.
 __ASSERT_DEBUG( EFalse, Panic( ECamCameraControllerCaeUnsupported ) );
 }
 // ---------------------------------------------------------------------------
 // McaeoVideoRecordingOn
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoVideoRecordingOn( TInt aError )
 {
 PRINT( _L("Camera => CCamCameraController::McaeoVideoRecordingOn") );
 #ifdef CAMERAAPP_CAE_ERR_SIMULATION
 HandleVideoEvent( ECamCameraEventVideoStart, aError );
 #else
 HandleVideoEvent( ECamCameraEventVideoStart, aError );
 #endif // CAMERAAPP_CAE_ERR_SIMULATION
 PRINT( _L("Camera <= CCamCameraController::McaeoVideoRecordingOn") );
 }
 // ---------------------------------------------------------------------------
 // McaeoVideoRecordingPaused
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoVideoRecordingPaused( TInt aError )
 {
 PRINT( _L("Camera => CCamCameraController::McaeoVideoRecordingPaused") );
 #ifdef CAMERAAPP_CAE_ERR_SIMULATION
 HandleVideoEvent( ECamCameraEventVideoPause, KErrUnknown );
 #else
 HandleVideoEvent( ECamCameraEventVideoPause, aError );
 #endif // CAMERAAPP_CAE_ERR_SIMULATION
 PRINT( _L("Camera <= CCamCameraController::McaeoVideoRecordingPaused") );
 }
 // ---------------------------------------------------------------------------
 // McaeoVideoRecordingComplete
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoVideoRecordingComplete( TInt aError )
 {
 PRINT( _L("Camera => CCamCameraController::McaeoVideoRecordingComplete") );
 #ifdef CAMERAAPP_CAE_ERR_SIMULATION
 {
 iCaeEngine->SetAsyncVideoStopMode( EFalse );
 }
 iAsyncVideoStopModeSupported = EFalse;
 }
 PRINT( _L("Camera <= CCamCameraController::McaeoVideoRecordingComplete") );
 }
 // ---------------------------------------------------------------------------
 // McaeoVideoRecordingTimes
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoVideoRecordingTimes(
 TTimeIntervalMicroSeconds aTimeElapsed,
 TTimeIntervalMicroSeconds aTimeRemaining,
 TInt aError )
 {
 HandleVideoTimeEvent( aError, aTimeElapsed, aTimeRemaining );
 }
 // ---------------------------------------------------------------------------
 // McaeoVideoRecordingStopped
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::McaeoVideoRecordingStopped()
 {
 PRINT( _L("Camera => CCamCameraController::McaeoVideoRecordingStopped") );
 #ifdef CAMERAAPP_CAE_ERR_SIMULATION
 // ---------------------------------------------------------------------------
 // ImageEncoded
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ImageEncoded( TInt aStatus, HBufC8* aData )
 {
 PRINT( _L("Camera => CCamCameraController::ImageEncoded") );
 MCameraBuffer* buffer = NULL;
 aData  = NULL; // ownership to buffer
 });
 }
 else
 {
 aStatus = KErrNotFound;
 }
 }
 else
 {
 // Just delete on errors
 delete aData;
 // ---------------------------------------------------------------------------
 // AttachObserverL
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::AttachObserverL( const MCamCameraObserver* aObserver,
 const TUint&              aInterest )
 {
 // Only add the observer once. NULL pointer only checked here.
 // Observer not added, if no notifications would be sent due to
 // event interest being ECamCameraEventClassNone.
 if( aObserver
 && ECamCameraEventClassNone != aInterest
 && KErrNotFound             == iObservers.Find( aObserver )
 )
 {
 // Try to add the observer to our list.
 TInt error = iObservers.Append( aObserver );
 // If we manage to add the observer, make sure the interest info gets set.
 if( KErrNone == error )
 {
 error = iObserverInterests.Append( aInterest );
 // If we are unable to add the interest info,
 // remove also the observer.
 if( KErrNone != error )
 {
 iObservers.Remove( iObservers.Count() - 1 );
 }
 }
 User::LeaveIfError( error );
 }
 }
 // ---------------------------------------------------------------------------
 // DetachObserver
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::DetachObserver( const MCamCameraObserver* aObserver )
 {
 if( aObserver )
 {
 // Ignore error if not found among observers
 // RequestL
 //
 // Issue request for one operation.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::RequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT1( _L("Camera => CCamCameraController::RequestL, request:[%s]"), KCamRequestNames[aRequestId] );
 CheckEqualsL( iInfo.iBusy, ECamBusyOff,  KErrInUse );
 SetFlags    ( iInfo.iBusy, ECamBusySingle );
 // If the request leaves, need to reset busy flag.
 CleanupStack::PushL( TCleanupItem( SetNotBusy, &iInfo.iBusy ) );
 PRINT( _L("Camera <> process request..") );
 proceed = ProcessOneRequestL( aRequestId );
 CleanupStack::Pop();
 // If this request will be responded through MCameraObserver(2) callback,
 // new requests cannot be accepted until that call arrives and
 // notification to our observers will be sent there.
 // Otherwise the request is fully processed from our point of view,
 // and new request can be accepted.
 PRINT( _L("Camera <> ..Request has no callback from CCamera, ready for new request.") );
 // Need to clear the busy flag before notification,
 // as observer might want to issue a new request during
 // the notification callback.
 ClearFlags( iInfo.iBusy, ECamBusySingle );
 if( ECamRequestVideoStop == aRequestId
 || ECamRequestSetAsyncVideoStopMode == aRequestId
 || ECamRequestImageCancel == aRequestId )
 {
 // For video stop request, callback has already happened and notification
 // has been given. No need to do anything here.
 }
 else
 {
 // Give notification to observers
 TCamCameraEventId event( Request2Event( aRequestId ) );
 NotifyObservers( KErrNone, event, EventClass( event ) );
 }
 }
 else
 PRINT( _L("Camera <= CCamCameraController::RequestL") );
 }
 // ---------------------------------------------------------------------------
 // DirectRequestL
 //
 // Issue request even when busy.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::DirectRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::DirectRequestL") );
 TBool notify( ETrue );
 ProcessImageRequestL( ECamRequestImageInit );
 break;
 // -----------------------------------------------------
 default:
 Panic( ECamCameraControllerUnsupported );
 break;
 }
 if( notify )
 {
 TCamCameraEventId event( Request2Event( aRequestId ) );
 //
 // Operations done during the sequence will be notified with
 // associated event codes to observers. If any errors happen during the
 // sequence, the notification will reflect this with the status code.
 // When sequence ends, observers will be notified with event
 // ECamCameraEventSequenceEnd. No new requests are accepted before
 // ECamCameraEventSequenceEnd notification is sent.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController
 ::RequestSequenceL( const RCamRequestArray& aSequence )
 {
 PRINT( _L("Camera => CCamCameraController::RequestSequence") );
 CheckEqualsL( iInfo.iBusy, ECamBusyOff,  KErrInUse );
 // ---------------------------------------------------------------------------
 // RequestSettingsChangeL
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::RequestSettingsChangeL()
 {
 PRINT ( _L("Camera => CCamCameraController::RequestSettingsChangeL") );
 CheckEqualsL( iInfo.iBusy, ECamBusyOff,  KErrInUse    );
 CheckFlagOnL( iInfo.iState, ECamReserved, KErrNotReady );
 TBool callback = ProcessSettingL( aSettingId );
 // If there is a callback, do notification there.
 if( !callback )
 {
 TCamCameraSettingId setting = aSettingId;
 NotifyObservers( KErrNone,
 ECamCameraEventSettingsSingle,
 ECamCameraEventClassSettings,
 &setting );
 }
 // ---------------------------------------------------------------------------
 // CancelSequence
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::CancelSequence()
 {
 PRINT( _L("Camera => CCamCameraController::CancelSequence") );
 if( iActive &&
 iActive->IsActive() )
 {
 PRINT( _L("Camera <> Busy, call EndSequence()..") );
 // Clears busy flag, if we were processing a sequence of requests / settings.
 // If iBusy is set because one request is on the way,
 // we must not clear it here - when that request is processed,
 // the flag will be cleared.
 EndSequence( KErrCancel );
 }
 PRINT( _L("Camera <= CCamCameraController::CancelSequence") );
 }
 // ---------------------------------------------------------------------------
 // SwitchCameraL
 void
 CCamCameraController::SwitchCameraL( TInt aCameraIndex )
 {
 PRINT1( _L("Camera => CCamCameraController::SwitchCameraL%d"),aCameraIndex );
 #ifdef _DEBUG
 if( aCameraIndex == iInfo.iCurrentCamera )
 {
 PRINT( _L("Camera <> CCamCameraController::SwitchCameraL - Changing Secondary camera orientation") );
 }
 #endif // _DEBUG
 if( aCameraIndex < 0 || aCameraIndex >= CamerasAvailable() )
 {
 User::Leave( KErrNotSupported );
 }
 else
 // First free old camera resources
 if( iCamera )
 {
 ReleaseCurrentCamera();
 }
 // used in CompleteSwitchCamera
 iCurrentCameraIndex = aCameraIndex;
 // -----------------------------------------------------
 // Then create new camera:
 PRINT ( _L("############################################################") );
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 PRINT1( _L("Camera <> Creating CCaeEngine, camera index: %d .."), aCameraIndex );
 iCaeEngine = NewCaeEngineL( aCameraIndex );
 #else
 PRINT ( _L("Camera <> Note: CCamera only in use, no CCaeEngine") );
 PRINT1( _L("Camera <> Creating CCamera, camera index: %d .."), aCameraIndex );
 else if( iCurrentCameraIndex == iInfo.iCurrentCamera )
 {
 return;
 }
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 #ifdef CAMERAAPP_CAE_FIX
 PRINT ( _L("Camera <> Creating new CCamera..") );
 iCamera    = NewCameraL( iCurrentCameraIndex );
 #else
 PRINT1( _L("Camera <> Creating CCamera duplicate, camera handle: %d .."), iCaeEngine->CCameraHandle() );
 iAdvancedSettings = CCamera::CCameraAdvancedSettings::NewL( *iCamera );
 #ifdef CAMERAAPP_CAPI_V2_IP
 if( KPrimaryCameraIndex == iInfo.iCurrentCamera )
 {
 // Support only for primary camera.
 // Ignore error in instantiation: If NewL leaves, there's no
 // support for Image Processing available. Report error to client
 // if settings requiring it are used.
 PRINT ( _L("Camera <> Create CCameraImageProcessing..") );
 TRAP_IGNORE( iImageProcessor = CCamera::CCameraImageProcessing::NewL( *iCamera ) );
 PRINT1( _L("Camera <> Image Processor pointer: %d"), iImageProcessor );
 // support for several setting. Not supported settings will not
 // cause this method to leave, only more serious errors.
 GetAdvancedSettingsInfoL();
 PRINT ( _L("Camera <> Get i/f MCameraOrientation..") )
 iCustomInterfaceOrientation =
 static_cast <MCameraOrientation*>(
 	    iCamera->CustomInterface( KCameraOrientationUid ) );
 PRINT1( _L("Camera <> Orientation custom i/f pointer:%d"), iCustomInterfaceOrientation );
 #endif // CAMERAAPP_CAPI_V2_ADV
 CCamCameraController::SetOrientationModeL( TInt aOrientation )
 {
 PRINT1( _L("Camera => CCamCameraController::SetOrientationModeL %d"), aOrientation );
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 PRINT( _L("Camera <> CCameraController: Get i/f MUIOrientationOverride from iCaeEngine..") )
 iCustomInterfaceUIOrientationOverride =
 static_cast <MCameraUIOrientationOverride*>(
 	    iCaeEngine->CustomInterface( KCameraUIOrientationOverrideUid ) );
 #else
 PRINT( _L("Camera <> CCameraController: Get i/f MUIOrientationOverride from iCamera..") )
 iCustomInterfaceUIOrientationOverride =
 static_cast <MCameraUIOrientationOverride*>(
 	    iCamera->CustomInterface( KCameraUIOrientationOverrideUid ) );
 #endif // CAMERAAPP_CAE_FOR_VIDEO
 PRINT1( _L("Camera <> OrientationOverride custom i/f pointer:%d"), iCustomInterfaceUIOrientationOverride );
 TRAP_IGNORE(iCustomInterfaceUIOrientationOverride->SetOrientationModeL( aOrientation ));
 PRINT( _L("Camera <= CCamCameraController::SetOrientationModeL") );
 }
 // ---------------------------------------------------------------------------
 // CamerasAvailable <<static>>
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController::CamerasAvailable()
 {
 #ifndef CAMERAAPP_CAPI_EMULATOR
 return CCamera::CamerasAvailable();
 #else
 // Temporary
 return 2;
 #endif
 }
 // ---------------------------------------------------------------------------
 // CameraHandle
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController::CameraHandle()
 {
 if( iCamera )
 return iCamera->Handle();
 else
 // ---------------------------------------------------------------------------
 // CameraInfo
 // ---------------------------------------------------------------------------
 //
 const TCameraInfo&
 CCamCameraController::CameraInfo() const
 {
 return iCameraInfo;
 }
 // ---------------------------------------------------------------------------
 // ControllerInfo
 // ---------------------------------------------------------------------------
 //
 const TCamControllerInfo&
 CCamCameraController::ControllerInfo() const
 {
 return iInfo;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TUint
 CCamCameraController::State() const
 {
 return iInfo.iState;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TCamViewfinderMode
 CCamCameraController::ViewfinderMode()  const
 {
 return iInfo.iVfMode;
 }
 CCamCameraController::ViewfinderState() const
 {
 return iInfo.iVfState;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TCamCameraTriState
 CCamCameraController::SnapshotState() const
 {
 return iInfo.iSsState;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TCamCameraReadyState
 CCamCameraController::FlashState() const
 {
 TCamCameraReadyState state = ECamUnknown;
 #ifdef CAMERAAPP_CAPI_V2_ADV
 if( iAdvancedSettings )
 {
 TBool ready       = EFalse;
 TInt  queryStatus = iAdvancedSettings->IsFlashReady( ready );
 }
 // -----------------------------------------------------
 case ECameraSettingExposure:
 case ECameraUserSceneSettingExposure:
 {
 TPckgBuf<TCamSettingDataExposure>* exposure =
 static_cast<TPckgBuf<TCamSettingDataExposure>*>( aSettingData );
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 (*exposure)().iExposureMode = iCaeEngine->ExposureMode();
 else
 {
 TInt* iso = static_cast<TInt*>( aSettingData );
 *iso = iAdvancedSettings->IsoRate();
 break;
 }
 case ECameraSettingContAF:
 {
 TInt* contAF = static_cast<TInt*>( aSettingData );
 *contAF = iAdvancedSettings->AutoFocusType() &  //bitwise
 CAS::EAutoFocusTypeContinuous;
 break;
 }
 #endif
 // -----------------------------------------------------
 case ECameraSettingWhiteBalance:
 case ECameraUserSceneSettingWhiteBalance:
 {
 TPckgBuf<TCamSettingDataWhiteBalance>* wb =
 static_cast<TPckgBuf<TCamSettingDataWhiteBalance>*>( aSettingData );
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 (*wb)().iWhiteBalanceMode = iCaeEngine->WhiteBalanceMode();
 case ECameraUserSceneSettingColourEffect:
 {
 CheckNonNullL( iImageProcessor, KErrNotSupported );
 CIP::TEffect* effect = static_cast<CIP::TEffect*>( aSettingData );
 *effect =
 (CIP::TEffect)
 iImageProcessor->TransformationValue( KUidECamEventImageProcessingEffect );
 break;
 }
 // -----------------------------------------------------
 }
 // -----------------------------------------------------
 case ECameraSettingBrightness:
 case ECameraUserSceneSettingBrightness:
 {
 CCamera::TBrightness* brightness =
 static_cast<CCamera::TBrightness*>( aSettingData );
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 *brightness = (CCamera::TBrightness)iCaeEngine->Brightness();
 else
 }
 // -----------------------------------------------------
 case ECameraSettingContrast:
 case ECameraUserSceneSettingContrast:
 {
 CCamera::TContrast* contrast =
 static_cast<CCamera::TContrast*>( aSettingData );
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 *contrast = (CCamera::TContrast)iCaeEngine->Contrast();
 else
 }
 #ifdef CAMERAAPP_CAPI_V2_ADV
 // -----------------------------------------------------
 case ECameraSettingStabilization:
 {
 TPckgBuf<TCamSettingDataStabilization>* pckg =
 static_cast<TPckgBuf<TCamSettingDataStabilization>*>( aSettingData );
 TCamSettingDataStabilization& stabilization = (*pckg)();
 stabilization.iMode       = iAdvancedSettings->StabilizationMode();
 stabilization.iEffect     = iAdvancedSettings->StabilizationEffect();
 // -----------------------------------------------------
 // Image orientation
 case ECameraSettingOrientation:
 {
 CheckNonNullL( iCustomInterfaceOrientation, KErrNotSupported );
 MCameraOrientation::TOrientation* orientation =
 static_cast<MCameraOrientation::TOrientation*>( aSettingData );
 *orientation = iCustomInterfaceOrientation->Orientation();
 break;
 // If the request made to CCamera has a callback, more calls from iActive
 // will not be requested here, but in those callbacks.
 // Leave here will cause iActive to call EndSequence with the error code.
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController::ProcessNextRequestL()
 {
 PRINT( _L("Camera => CCamCameraController::ProcessNextRequestL") );
 TInt readyForNextStep( EFalse );
 iSequenceIndex++;
 if( iSequenceIndex < iSequenceArray.Count() )
 {
 const TCamCameraRequestId& requestId( iSequenceArray[iSequenceIndex] );
 PRINT( _L("Camera <> process request..") );
 // If this request will be responded through MCameraObserver(2) callback,
 // iActive will be requested a new callback there and also
 // the notification to our observers will be sent there.
 // Otherwise we do both of those right away.
 readyForNextStep = ProcessOneRequestL( requestId );
 if( readyForNextStep )
 {
 if( ECamRequestVideoStop == requestId
 || ECamRequestImageCancel == requestId )
 {
 // For video stop request, callback has already happened and notification
 // has been given. No need to do anything here.
 PRINT( _L("Camera <> CCamCameraController::RequestL .. Skipping commmon notification, is done already.") );
 }
 else
 {
 TCamCameraEventId event( Request2Event( requestId ) );
 NotifyObservers( KErrNone, event, EventClass( event ) );
 }
 }
 }
 else
 // ---------------------------------------------------------------------------
 // ProcessSettingL
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController::ProcessSettingL( const TCamCameraSettingId& aSettingId )
 {
 PRINT1( _L("Camera => CCamCameraController::ProcessSettingL [%s]"),
 KCameraSettingNames[aSettingId] );
 TInt callback( EFalse );
 switch( aSettingId )
 {
 }
 // -------------------------------
 case ECameraSettingFlash:
 case ECameraUserSceneSettingFlash:
 {
 if ( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 {
 CCamera::TFlash flash( CCamera::EFlashNone );
 TCamFlashId currentFlashSetting( ECamFlashOff );
 // Video light setting has values ECamFlashOff/ECamFlashForced
 iSettingProvider.ProvideCameraSettingL( aSettingId,
 &currentFlashSetting );
 PRINT2( _L("Camera => Video Flash now = %d, new = %d"),
 iCamera->Flash(), currentFlashSetting );
 // Camera uses values EFlashNone/EFlashVideoLight
 flash = (currentFlashSetting == ECamFlashOff)?
 CCamera::EFlashNone:CCamera::EFlashVideoLight;
 PRINT1( _L("Camera => iCamera->SetFlashL( %d )"), flash );
 iCamera->SetFlashL( flash );
 }
 else
 {
 // Still image flash
 CCamera::TFlash flash( CCamera::EFlashAuto );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &flash );
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 {
 iCaeEngine->SetFlashModeL( flash );
 }
 else
 #endif
 {
 if( iCamera->Flash() != flash )
 // (CCamera::EExposureAuto)
 if( mode == CCamera::EExposureAuto || mode & iAdvancedSettingInfo.iEvModesSupport )
 {
 iAdvancedSettings->SetExposureMode( mode );
 // iCamera->SetExposureL( mode );
 TInt step = ResolveEvStep( params().iExposureStep );
 // Value needs to be multiplied by KECamFineResolutionFactor.
 // Setting provider does this for us.
 PRINT( _L("Calling iAdvancedSettings->SetExposureCompensationStep..") );
 iAdvancedSettings->SetExposureCompensationStep( step );
 iAdvancedSettings->GetSupportedIsoRatesL( ISOarray );
 iSettingProvider.SetSupportedISORatesL( ISOarray );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &iso );
 callback = ETrue;
 CleanupStack::PopAndDestroy( &ISOarray );
 PRINT1( _L("Camera <> Setting ISO rate to: %d"), iso );
 if( !iso )
 {
 // ISO Auto
 iAdvancedSettings->SetISORateL(
 CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised, iso );
 }
 else if( IsSupportedValue( iso,
 iAdvancedSettingInfo.iIsoRatesSupport,
 EDiscreteSteps ) )
 {
 // Selected ISO rate
 iAdvancedSettings->SetISORateL(
 CCamera::CCameraAdvancedSettings::EISOManual, iso );
 }
 else
 {
 User::Leave( KErrNotSupported );
 }
 break;
 }
 #endif
 // -------------------------------
 #endif // CAMERAAPP_CAE_FIX
 {
 iCamera->SetWhiteBalanceL( params().iWhiteBalanceMode );
 #ifdef CAMERAAPP_CAPI_V2
 callback = ETrue;
 #endif
 }
 break;
 }
 // -------------------------------
 #ifdef CAMERAAPP_CAPI_V2_IP
 {
 CheckNonNullL( iImageProcessor, KErrNotSupported );
 CIP::TEffect effect( CIP::EEffectNone );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &effect );
 if( IsSupportedValue( effect,
 iAdvancedSettingInfo.iColourEffectSupport,
 iAdvancedSettingInfo.iColourEffectValueInfo ) )
 {
 iImageProcessor->SetTransformationValue( KUidECamEventImageProcessingEffect, effect );
 callback = ETrue;
 }
 {
 CheckNonNullL( iImageProcessor, KErrNotSupported );
 TInt sharpness( 0 );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &sharpness );
 if( IsSupportedValue( sharpness,
 iAdvancedSettingInfo.iSharpnessSupport,
 iAdvancedSettingInfo.iSharpnessValueInfo ) )
 {
 iImageProcessor->SetTransformationValue( KUidECamEventImageProcessingAdjustSharpness, sharpness );
 callback = ETrue;
 }
 #endif
 {
 #ifdef CAMERAAPP_CAPI_V2_ADV
 if( iAdvancedSettingInfo.iDigitalZoomSupport.Count() > zoom )
 iAdvancedSettings->SetDigitalZoom( iAdvancedSettingInfo.iDigitalZoomSupport[zoom] );
 else
 User::Leave( KErrNotSupported );
 callback = ETrue;
 #else
 // Note: Even if the method is misleadingly named
 //       CCamera::SetDigitalZoomFactorL, the values are
 //       zoom steps, not zoom factors.
 iCamera->SetDigitalZoomFactorL( zoom );
 #endif
 }
 break;
 }
 // -------------------------------
 #ifdef CAMERAAPP_CAPI_V2_ADV
 case ECameraSettingStabilization:
 {
 PRINT( _L("Camera <> CCamCameraController::ProcessSettingL ECameraSettingStabilization") );
 TPckgBuf<TCamSettingDataStabilization> stabilization;
 iSettingProvider.ProvideCameraSettingL( aSettingId, &stabilization );
 // Check that the values are supported..
 TBool modeOk    = ( CAS::EStabilizationModeOff == stabilization().iMode
 || iAdvancedSettingInfo.iStabilizationModeSupport & stabilization().iMode );
 TBool effectOk  = ( CAS::EStabilizationOff     == stabilization().iEffect
 || iAdvancedSettingInfo.iStabilizationEffectSupport & stabilization().iEffect );
 TBool complexOk = ( CAS::EStabilizationComplexityAuto == stabilization().iComplexity
 || iAdvancedSettingInfo.iStabilizationComplexitySupport & stabilization().iComplexity );
 if( modeOk && effectOk && complexOk )
 {
 PRINT1( _L("Camera <> CCamCameraController::ProcessSettingL set stabilization mode=%d"), stabilization().iMode );
 iAdvancedSettings->SetStabilizationMode      ( stabilization().iMode       );
 iAdvancedSettings->SetStabilizationEffect    ( stabilization().iEffect     );
 iAdvancedSettings->SetStabilizationComplexity( stabilization().iComplexity );
 // Events:
 //   KUidECamEventCameraSettingStabilizationMode
 //   KUidECamEventCameraSettingsStabilizationEffect
 //   KUidECamEventSettingsStabilizationAlgorithmComplexity
 // We use the latest one to determine when we can continue.
 // Do not change above order unless CCamSettingConversion::Map2EventUidValue
 // is edited..
 }
 else
 callback = ETrue;
 break;
 }
 // -------------------------------
 case ECameraSettingContAF:
 {
 CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
 if ( appUi->AppController().UiConfigManagerPtr()->IsContinuosAutofocusSupported() )
 {
 TBool isContAFon( iAdvancedSettings->AutoFocusType() &
 CAS::EAutoFocusTypeContinuous );
 if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 {
 TBool contAF( ETrue );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &contAF );
 callback = IsFlagOn( iInfo.iState, ECamVideoOn );
 }
 }
 else
 {
 //
 PRINT( _L("Camera <> Video file size too early, NOT SET!!") );
 }
 break;
 }
 // -------------------------------
 case ECameraSettingFileName:
 // and needs to be waited.
 callback = IsFlagOn( iInfo.iState, ECamVideoOn );
 }
 else
 {
 PRINT( _L("Camera <> Video name too early, NOT SET!!") );
 }
 break;
 }
 // -------------------------------
 case ECameraSettingAudioMute:
 callback = IsFlagOn( iInfo.iState, ECamVideoOn );
 }
 }
 else
 {
 PRINT( _L("Camera <> Video mute too early, NOT SET!!") );
 }
 break;
 }
 // -------------------------------
 case ECameraSettingFacetracking:
 {
 // -------------------------------
 // Image orientation
 case ECameraSettingOrientation:
 {
 CheckNonNullL( iCustomInterfaceOrientation, KErrNotSupported );
 MCameraOrientation::TOrientation
 orientation( MCameraOrientation::EOrientation0 );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &orientation );
 if ( iInfo.iCurrentCamera != KPrimaryCameraIndex &&
 orientation == MCameraOrientation::EOrientation90 )
 {
 PRINT( _L("Camera <> Rotate portrait secondary camera image 270 degrees") );
 orientation = MCameraOrientation::EOrientation270;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessOneRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessOneRequestL") );
 PRINT2( _L("Camera <> processing request [%s] id:%d "),
 KCamRequestNames[aRequestId],
 aRequestId );
 TInt readyForNext( ETrue );
 // Order from most time critical / frequent
 // to less time critical / seldom.
 // Handled in submethods to preserve readability.
 // -----------------------------------------------------
 switch( aRequestId )
 {
 // ---------------------------------------------------------------------------
 // ProcessControlStartupRequestL
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessControlStartupRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT1( _L("Camera => CCamCameraController::ProcessControlStartupRequestL [%s]"),
 KCamRequestNames[aRequestId] );
 CAMERAAPP_PERF_CONTROLLER_START( ECamRequestReserve );
 iCamera->Reserve();
 // If UIOrientationOverrideAPI is used, ui construction is completed while
 // waiting for Reserve to complete, event sent here to continue ui construction
 CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
 if ( appUi->AppController().UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )
 {
 NotifyObservers( KErrNone,
 ECamCameraEventReserveRequested,
 ECamCameraEventClassBasicControl );
 }
 }
 // -------------------------------------------------------
 CheckFlagOnL ( iInfo.iState, ECamReserved, KErrNotReady );
 CheckFlagOffL( iInfo.iState, ECamPowerOn,  KErrInUse    );
 CAMERAAPP_PERF_CONTROLLER_START( ECamRequestPowerOn );
 iCamera->PowerOn();
 }
 // -------------------------------------------------------
 // Unknown
 else
 {
 Panic( ECamCameraControllerCorrupt );
 }
 // -------------------------------------------------------
 iReleasedByUi = EFalse;
 PRINT( _L("Camera <= CCamCameraController::ProcessControlStartupRequestL") );
 // Callback needs to be received before we can continue.
 return EFalse;
 }
 // ---------------------------------------------------------------------------
 // ProcessControlShutdownRequest
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessControlShutdownRequest( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessControlShutdownRequest") );
 // -------------------------------------------------------
 // Power off
 if( ECamRequestPowerOff == aRequestId )
 {
 if( IsFlagOn( iInfo.iState, ECamPowerOn ) )
 {
 // -------------------------------
 // Release image or video capture
 if( IsFlagOn( iInfo.iState, ECamImageOn ) )
 {
 // Leaves only if state is wrong (already checked here).
 ProcessImageShutdownRequest( ECamRequestImageRelease );
 NotifyObservers( KErrNone,
 ECamCameraEventImageRelease,
 ECamCameraEventClassImage );
 }
 else if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 {
 TRAP_IGNORE( ProcessVideoRequestL( ECamRequestVideoRelease ) );
 NotifyObservers( KErrNone,
 ECamCameraEventVideoRelease,
 ECamCameraEventClassVideo );
 }
 else
 {
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 {
 iCaeEngine->PowerOff();
 }
 else
 #endif // CAMERAAPP_CAE_FIX
 {
 iCamera->PowerOff();
 }
 // -------------------------------
 }
 ClearFlags( iInfo.iState, ECamPowerOn );
 }
 }
 else
 #endif // CAMERAAPP_CAE_FIX
 {
 iCamera->Release();
 iReleasedByUi = ETrue;
 if( iIveRecoveryCount > 0 )
 {
 HandleReserveLostEvent( KErrNone );
 }
 }
 }
 PRINT( _L("Camera <> released, reset info") );
 // Reset our info, but preserve busy flag and camera index.
 // Sets iInfo.iState to ECamIdle.
 iInfo.Reset( ETrue, ETrue );
 }
 // -------------------------------------------------------
 // Unknown
 else
 {
 Panic( ECamCameraControllerCorrupt );
 }
 // -------------------------------------------------------
 PRINT( _L("Camera <= CCamCameraController::ProcessControlShutdownRequest") );
 // No callback needs to be waited.
 return ETrue;
 }
 // ---------------------------------------------------------------------------
 // ProcessViewfinderRequestL
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessVfRequestL( const TCamCameraRequestId& aRequestId )
 {
 CheckFlagOnL( iInfo.iState, ECamPowerOn, KErrNotReady );
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::InitViewfinderL( const TCamViewfinderMode& aMode )
 {
 PRINT( _L("Camera => CCamCameraController::InitViewfinderL") );
 // Check the old viewfinder is released now.
 // No further checks made here.
 __ASSERT_DEBUG( ECamTriIdle == iInfo.iVfState, Panic( ECamCameraControllerCorrupt ) );
 {
 // ---------------------------------
 case ECamViewfinderDirect:
 {
 // Don't proceed if not supported by camera.
 CheckFlagOnL( iCameraInfo.iOptionsSupported,
 TCameraInfo::EViewFinderDirectSupported,
 KErrNotSupported );
 #ifdef CAMERAAPP_CAPI_V2_DVF
 PRINT( _L("Camera <> Creating CCameraDirectViewFinder instance") );
 if( iDirectViewfinder )
 {
 	delete iDirectViewfinder;
 	iDirectViewfinder=NULL;
 }
 iDirectViewfinder = CCamera::CCameraDirectViewFinder::NewL( *iCamera );
 #else
 // not implemented
 Panic( ECamCameraControllerUnsupported );
 #endif
 iInfo.iVfState  = ECamTriInactive;
 iInfo.iVfMode   = ECamViewfinderDirect;
 break;
 }
 // ---------------------------------
 case ECamViewfinderBitmap:
 {
 // Don't proceed if not supported by camera.
 CheckFlagOnL( iCameraInfo.iOptionsSupported,
 TCameraInfo::EViewFinderBitmapsSupported,
 KErrNotSupported );
 iInfo.iVfState  = ECamTriInactive;
 iInfo.iVfMode   = ECamViewfinderBitmap;
 break;
 }
 // ---------------------------------
 // Mode is "none", so no init needed.
 break;
 // ---------------------------------
 default:
 // Unknown mode
 Panic( ECamCameraControllerUnsupported );
 break;
 // ---------------------------------
 }
 PRINT( _L("Camera <= CCamCameraController::InitViewfinderL") );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 void
 {
 PRINT( _L("Camera => CCamCameraController::ProcessVfStartRequestL") );
 #ifdef __WINSCW__
 const TCamViewfinderMode KTargetMode( ECamViewfinderBitmap );
 #else
 TPckgBuf<TCamViewfinderMode> mode;
 iSettingProvider.ProvideCameraParamL( ECameraParamVfMode, &mode );
 // If the viewfinder mode needs to be changed,
 // first stop and release resources related to the old viewfinder type.
 const TCamViewfinderMode KTargetMode( mode() );
 #endif
 && KTargetMode        != iInfo.iVfMode )
 {
 ProcessVfRelaseRequest();
 }
-// Check that application is still in foreground, if not then return
+// Check that application is still in foreground, if not, then vf not started.
 CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi && appUi->AppInBackground( ETrue ) )
-if ( !appUi->AppInBackground( ETrue ) )
+{
+// Notify appUi that we did not start viewfinder although asked to do so.
+appUi->SetViewFinderStoppedStatus( iInfo.iVfState != ECamTriActive );
+}
+else
 {
 switch( iInfo.iVfState )
 {
 // -----------------------------------------------------
 case ECamTriIdle:
 PRINT( _L("Camera <> case ECamTriIdle") );
 InitViewfinderL( KTargetMode );
 // << fall through >>
 case ECamTriInactive:
 {
 // -------------------------------
 PRINT( _L("Camera <> case ECamTriInactive") );
 if( ECamViewfinderDirect == iInfo.iVfMode )
 #ifdef CAMERAAPP_CAPI_V2_DVF
 {
 switch( iDirectViewfinder->ViewFinderState() )
 {
 if ( !iViewfinderWindow )
 {
 PRINT( _L("Camera <> CCamCameraController::iViewfinderWindow is NULL - cannot start VF!") );
 User::Leave( KErrNotReady );
 }
 // Use the same viewfinder position and size as for bitmap viewfinder
 TPckgBuf<TCamParamsVfBitmap> params;
 iSettingProvider.ProvideCameraParamL( ECameraParamVfBitmap, &params );
 CEikonEnv* env = CEikonEnv::Static();
 OstTrace0( CAMERAAPP_PERFORMANCE, CCAMCAMERACONTROLLER_PROCESSVFSTARTREQUESTL, "e_CAM_APP_VF_INIT 0" ); //CCORAPP_APP_VF_INIT_END
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMCAMERACONTROLLER_PROCESSVFSTARTREQUESTL, "e_CAM_APP_OVERLAY_INIT 0" ); //CCORAPP_APP_OVERLAY_INIT_END
 TInt orgPos = SetVfWindowOrdinal(); // Set visible
 iCamera->StartViewFinderDirectL(
 env->WsSession(),
 *env->ScreenDevice(),
 *iViewfinderWindow,
 params().iRect );
 (void) SetVfWindowOrdinal( orgPos ); // back to original
-CCamAppUi* appUi = static_cast<CCamAppUi*>( env->AppUi() );
+if ( ECamActiveCameraSecondary == appUi->ActiveCamera() )
-if ( ECamActiveCameraSecondary == appUi->ActiveCamera() )
 {
 iCamera->SetViewFinderMirrorL(ETrue);
 }
 // VF started succesfully, reset recovery counter
 delete iIdle;
 iIdle = NULL;
 iIveRecoveryCount = KIveRecoveryCountMax;
 break;
 }
 case CCamera::CCameraDirectViewFinder::EViewFinderPause:
 {
 iDirectViewfinder->ResumeViewFinderDirectL();
 }
 case CCamera::CCameraDirectViewFinder::EViewFinderActive:
 {
 // Already running. Not considered as error.
 break;
 }
 default:
 {
 Panic( ECamCameraControllerUnsupported );
 break;
 }
 }
 }
 #else // CAMERAAPP_CAPI_V2_DVF
 {
 // No controller support for direct vf.
 Panic( ECamCameraControllerUnsupported );
 }
 #endif // CAMERAAPP_CAPI_V2_DVF
 // -------------------------------
 else
 {
 PRINT( _L("Camera <> Get bitmap vf details..") );
 TPckgBuf<TCamParamsVfBitmap> params;
 iSettingProvider.ProvideCameraParamL( ECameraParamVfBitmap, &params );
 iInfo.iViewfinderFormat = params().iFormat;
 iInfo.iViewfinderSize   = params().iRect.Size();
 #ifdef CAMERAAPP_CAE_FIX
 if( iCaeInUse )
 {
 PRINT( _L("Camera <> Call CCaeEngine::StartViewFinderBitmapsL..") );
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMCAMERACONTROLLER_PROCESSVFSTARTREQUESTL, "e_CAM_APP_VF_INIT 0" ); //CCORAPP_APP_VF_INIT_END
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMCAMERACONTROLLER_PROCESSVFSTARTREQUESTL, "e_CAM_APP_OVERLAY_INIT 0" ); //CCORAPP_APP_OVERLAY_INIT_END
 iCaeEngine->StartViewFinderBitmapsL( iInfo.iViewfinderSize );
 }
 else
 #endif // CAMERAAPP_CAE_FIX
 {
 PRINT( _L("Camera <> Call CCamera::StartViewFinderBitmapsL..") );
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMCAMERACONTROLLER_PROCESSVFSTARTREQUESTL, "e_CAM_APP_VF_INIT 0" );  //CCORAPP_APP_VF_INIT_END
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMCAMERACONTROLLER_PROCESSVFSTARTREQUESTL, "e_CAM_APP_OVERLAY_INIT 0" ); //CCORAPP_APP_OVERLAY_INIT_END
 iCamera->StartViewFinderBitmapsL( iInfo.iViewfinderSize );
 		  if ( params().iMirrorImage )
 		  	{
 		   	iCamera->SetViewFinderMirrorL( params().iMirrorImage );
 		   	}
 }
 }
 // -------------------------------
 iInfo.iVfState = ECamTriActive;
 //view finder started now(set stop status as false)
 appUi->SetViewFinderStoppedStatus( EFalse );
 break;
 }
 // -----------------------------------------------------
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 // -----------------------------------------------------
 }
 }
 PRINT( _L("Camera <= CCamCameraController::ProcessVfStartRequestL") );
 }
 case ECamTriActive:
 {
 // Do the stopping first and continue then with release.
 // Leaves only if iVfState is ECamVfIdle, which is not the case here.
 TRAP_IGNORE( ProcessVfStopRequestL() );
 // Need to notify here, because done as a part of other request.
 NotifyObservers( KErrNone,
 ECamCameraEventVfStop,
 ECamCameraEventClassVfControl );
 // << fall through >>
 }
 // -----------------------------------------------------
 {
 // No further actions needed for bitmap viewfinding.
 }
 // These may very well remain as they are.
 // Atleast for the format there is no "zero" value available.
 //    iInfo.iViewfinderSize
 //    iInfo.iViewfinderFormat
 iInfo.iVfState          = ECamTriIdle;
 iInfo.iVfMode           = ECamViewfinderNone;
 break;
 }
 // ---------------------------------------------------------------------------
 // ProcessImageRequestL
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessImageRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessImageRequestL") );
 CheckFlagOnL( iInfo.iState, ECamPowerOn, KErrNotReady );
 {
 // -----------------------------------------------------
 case ECamRequestImageInit:
 {
 // When camera engine still capture don't Init a new capture
 if ( ECamCaptureOn == iInfo.iCaptureState )
 	{
 	return EFalse;
 	}
 CAMERAAPP_PERF_CONTROLLER_START( ECamRequestImageInit );
 if( iCaeInUse )
 {
 iModeChange       = ECamModeChangeVideo2Image;
 iModeChangePhase  = ECamModeChangePhaseIdle;   // incremented before first step
 iModeChangeStatus = KErrNone;
 iActive->IssueRequest();
 }
 else
 #else
 if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 {
 // Release any video recording resources
 iCaeEngine->CloseVideoRecording();
 {
 PRINT( _L("Camera <> Checking that image capture not ongoing..") );
 CheckEqualsL( iInfo.iCaptureState, ECamCaptureOff, KErrInUse    );
 PRINT( _L("Camera <> Checking that image capture supported..") );
 CheckFlagOnL( iCameraInfo.iOptionsSupported,
 TCameraInfo::EImageCaptureSupported,
 KErrNotSupported );
 PRINT( _L("Camera <> Ask image parameters..") );
 TPckgBuf<TCamParamsImage> params;
 iSettingProvider.ProvideCameraParamL( ECameraParamImage, &params );
 CCamera::TFormat format( params().iFormat );
 TInt index = GetResolutionIndexL( format, params().iSize );
 User::LeaveIfError( index );
 PRINT( _L("Camera <> Call CCamera::PrepareImageCaptureL..") );
 PRINT2( _L("Camera <> Image size: (%d, %d)"),
 params().iSize.iWidth,
 params().iSize.iHeight );
 OstTrace0( CAMERAAPP_PERFORMANCE, CCAMCAMERACONTROLLER_PROCESSIMAGEREQUESTL, "e_CAM_APP_CONFIGURATIONS 0" );  //CCORAPP_APP_CONFIGS_END
 iCamera->PrepareImageCaptureL( format, index );
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMCAMERACONTROLLER_PROCESSIMAGEREQUESTL, "e_CAM_APP_STILL_INIT 0" ); //CCORAPP_APP_STILL_INIT_END
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMCAMERACONTROLLER_PROCESSIMAGEREQUESTL, "e_CAM_APP_OVERLAY_INIT 1" );   //CCORAPP_APP_OVERLAY_INIT_START
 iCamera->SetJpegQuality( params().iQualityFactor );
 SetFlags( iInfo.iState, ECamImageOn );
 #ifdef CAMERAAPP_CAPI_V2_ADV
 // Set current autofocus range to invalid value to force focusing
 iInfo.iCurrentFocusRange = static_cast<CAS::TFocusRange>( -1 );
 GetAdvancedSettingsInfoL();
 #endif // CAMERAAPP_CAPI_V2_ADV
 iInfo.iCaptureCount  = 0;
 iInfo.iSnapshotCount = 0;
 callback = EFalse; // No callback to wait for.
 CAMERAAPP_PERF_CONTROLLER_STOP( ECamRequestImageInit );
 }
 iInfo.iSnapshotCount = 0;
 iInfo.iCaptureState  = ECamCaptureOn;
 PRINT1( _L("Camera <> CCamCameraController .. About to start capture, total shared buffers in use: %d"), CCamBufferShare::TotalBufferShareCount() );
 iCamera->CaptureImage();
 // When image data is received from CCamera,
 // an event is generated for that. We need to notify
 // here as other places check if the request has associated
 // callback, and send no notification yet if callback exist.
 NotifyObservers( KErrNone,
 ECamCameraEventImageStart,
 ECamCameraEventClassImage );
 break;
 }
 // -----------------------------------------------------
 }
 // -----------------------------------------------------
 }
 PRINT1( _L("Camera <= CCamCameraController::ProcessImageRequestL, continue now:%d"), !callback );
 return !callback;
 }
 // ---------------------------------------------------------------------------
 // ProcessImageShutdownRequest
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessImageShutdownRequest( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessImageShutdownRequest") );
 {
 // -----------------------------------------------------
 case ECamRequestImageCancel:
 {
 if( IsFlagOn( iInfo.iState, ECamImageOn )
 //      && ECamCaptureOn == iInfo.iCaptureState
 )
 {
 const TCamCameraCaptureState previousState( iInfo.iCaptureState );
 if( iEncoder )
 {
 iEncoder->Cancel();
 delete iEncoder;
 iEncoder = NULL;
 }
 PRINT( _L("Camera <> Calling iCamera->CancelCaptureImage()") );
 iCamera->CancelCaptureImage();
 iInfo.iCaptureState = ECamCaptureOff;
 // Capturing image was stopped here.
 // If single request was ongoing, it must be "capture image".
 ClearFlags( iInfo.iBusy, ECamBusySingle );
 TInt fullCaptures( Min( iInfo.iCaptureCount, iInfo.iSnapshotCount ) );
 NotifyObservers( KErrNone,
 ECamCameraEventImageStop,
 ECamCameraEventClassImage,
 &fullCaptures );
 }
 }
 break;
 {
 // Cancel any pending capture.
 ProcessImageShutdownRequest( ECamRequestImageCancel );
 // Nothing else really needed for image, just set flags.
 ClearFlags( iInfo.iState, ECamImageOn );
 iInfo.iCaptureCount  = 0;
 iInfo.iSnapshotCount = 0;
 iInfo.iCaptureState  = ECamCaptureOff;
 break;
 }
 // -----------------------------------------------------
 }
 PRINT( _L("Camera <= CCamCameraController::ProcessImageShutdownRequest") );
 return ETrue; // can continue sequence, if needed
 }
 // ---------------------------------------------------------------------------
 // ProcessVideoRequestL
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessVideoRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessVideoRequestL") );
 CheckFlagOnL( iInfo.iState, ECamPowerOn, KErrNotReady );
 TPtr   ptr     ( filename->Des()              );
 iSettingProvider.ProvideCameraSettingL( ECameraSettingFileName, &ptr );
 // _LIT( KTempFilename, "C:\\video.3gp" );
 // TPtrC ptr;
 // ptr.Set( KTempFilename() );
 PRINT1( _L("Camera <> Set filename [%S]"), &ptr );
 iCaeEngine->SetVideoRecordingFileNameL( ptr );
 CleanupStack::PopAndDestroy( filename );
 // Set max video clip size
 ProcessSettingL( ECameraSettingFileMaxSize );
 TPckgBuf<TCamParamsVideoCae> params;
 PRINT( _L("Camera <> Getting params from setting provider..") );
 iSettingProvider.ProvideCameraParamL( ECameraParamVideoCae, &params );
 // The audioOn value is defined On==0 and Off==1, but the engine expects
 // ETrue if audio recording is On
 params().iAudioOn = ( ECamSettOn == params().iAudioOn )
 											? ETrue
 											: EFalse;
 PRINT( _L("Camera <> Calling PrepareVideoRecordingL..") );
 params().iMimeType,
 params().iSupplier,
 params().iVideoType,
 params().iAudioType );
 }
 #ifdef CAMERAAPP_CAPI_V2_ADV
 // Set current autofocus range to invalid value to force focusing
 iInfo.iCurrentFocusRange = static_cast<CAS::TFocusRange>( -1 );
 #endif // CAMERAAPP_CAPI_V2_ADV
 iAppController.SetVideoInitNeeded( EFalse );
 // iState is updated in the callback.
 PRINT( _L("Camera <> ..waiting for callback") );
 }
 break;
 {
 case ECamCaptureOn:     User::Leave( KErrInUse );           break;
 case ECamCaptureOff:    iCaeEngine->StartVideoRecording();  break;
 //case ECamCaptureOff:    iCaeEngine->ResumeVideoRecording();  break;
 case ECamCapturePaused: iCaeEngine->ResumeVideoRecording(); break;
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 }
 // iCaptureState is updated in McaeoVideoRecordingOn.
 break;
 {
 PRINT( _L("Camera <> case ECamRequestVideoStop") );
 switch( iInfo.iCaptureState )
 {
 case ECamCaptureOn:     // << fall through >>
 case ECamCapturePaused:
 PRINT( _L("Camera <> call CCaeEngine::StopVideoRecording..") );
 iCaeEngine->StopVideoRecording();
 // If we got the callback during above call,
 // we should not wait for it anymore.
 // Check the capture state to be sure.
 callback = (ECamCaptureOff != iInfo.iCaptureState);
 break;
 case ECamCaptureOff:
 // no action, already stopped
 break;
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 }
 // iCaptureState is updated in McaeoVideoRecordingComplete.
 break;
 // -----------------------------------------------------
 case ECamRequestVideoRelease:
 {
 // Need to be stopped.
 CheckEqualsL( iInfo.iCaptureState, ECamCaptureOff, KErrInUse );
 if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 iCaeEngine->CloseVideoRecording();
 ClearFlags( iInfo.iState, ECamVideoOn );
 callback = EFalse;
 #ifdef CAMERAAPP_CAPI_V2_ADV
 GetAdvancedSettingsInfoL();
 #endif
 iAsyncVideoStopModeSupported = !err; // Use async stop if KErrNone
 callback = EFalse;
 break;
 }
 // -----------------------------------------------------
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 // -----------------------------------------------------
 }
 #else
 #pragma message("CCamCameraController::ProcessVideoRequestL not implemented!")
 // ---------------------------------------------------------------------------
 // ProcessSnapshotRequestL
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController
 ::ProcessSnapshotRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessSnapshotRequestL") );
 OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMCAMERACONTROLLER_PROCESSSNAPSHOTREQUESTL, "e_CCamCameraController_ProcessSnapshotRequestL 1" );
 PRINT( _L("Camera <> ECamTriIdle") );
 InitSnapshotL();
 // << fall through >>
 case ECamTriInactive:
 {
 PRINT( _L("Camera <> ECamTriInactive") );
 iSnapshotProvider->StartSnapshot();
 break;
 }
 case ECamTriActive: // Already active, no action
 PRINT( _L("Camera <> ECamTriActive") );
 break;
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 }
 iInfo.iSsState = ECamTriActive;
 break;
 }
 {
 case ECamTriIdle:     // Not even initialized yet. No action needed.
 case ECamTriInactive: // Already inactive, no action.
 PRINT( _L("Camera <> Snapshot idle/inactive, no need to stop") );
 break;
 case ECamTriActive:
 PRINT( _L("Camera <> Snapshot ECamTriActive -> need to stop") );
 iSnapshotProvider->StopSnapshot();
 break;
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 }
 iInfo.iSsState = ECamTriInactive;
 PRINT( _L("Camera <= CCamCameraController::ProcessSsStopRequest") );
 }
 {
 case ECamTriIdle:    // No action needed
 break;
 case ECamTriActive:
 iSnapshotProvider->StopSnapshot();
 NotifyObservers( KErrNone,
 ECamCameraEventSsStop,
 ECamCameraEventClassSsControl );
 // << fall through >>
 case ECamTriInactive:
 delete iSnapshotProvider;
 iSnapshotProvider = NULL;
 break;
 default:
 Panic( ECamCameraControllerCorrupt );
 break;
 }
 iInfo.iSsState = ECamTriIdle;
 PRINT( _L("Camera <= CCamCameraController::ProcessSsReleaseRequest") );
 }
 // ---------------------------------------------------------------------------
 // InitSnapshotL
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::InitSnapshotL()
 {
 PRINT( _L("Camera => CCamCameraController::InitSnapshotL") );
 // Check the snapshot state here. No further checks made.
 PrintSnapshotInfo();
 #endif // _DEBUG
 // -------------------------------------------------------
 // Initialize the snapshot parameters
 TPckgBuf<TCamParamsSnapshot> params;
 iSettingProvider.ProvideCameraParamL( ECameraParamSnapshot, &params );
 // Try to get the best, still supported, snapshot format.
 iInfo.iSnapshotFormat         = ResolveSnapshotFormatL( params().iFormat );
 iInfo.iSnapshotSize           = params().iSize;
 iInfo.iSnapshotAspectMaintain = params().iMaintainAspect;
 PRINT( _L("Camera <> Prepare snapshot..") );
 // CCamCameraController::ProcessAutofocusRequestL
 // ---------------------------------------------------------------------------
 //
 void CCamCameraController::ProcessAutofocusRequestL( const TCamCameraRequestId& aRequestId )
 {
 PRINT( _L("Camera => CCamCameraController::ProcessAutofocusRequestL") );
 #ifdef CAMERAAPP_CAPI_V2_ADV
 CheckNonNullL( iAdvancedSettings, KErrNotReady );
 if( ECamRequestStartAutofocus == aRequestId )
 {
 PRINT( _L("Camera <> SetAutoFocusType( EAutoFocusTypeSingle )") );
 iAdvancedSettings->SetAutoFocusType( CAS::EAutoFocusTypeSingle );
 iAfInProgress = ETrue;
 iFirstAfEventReceived = EFalse;
 }
 else if( ECamRequestCancelAutofocus == aRequestId )
 {
 if( iAfInProgress )
 {
 // Autofocus in progress, need to cancel it before setting range to hyperfocal
 PRINT( _L("Camera <> Cancel ongoing autofocus request") );
 iAdvancedSettings->SetAutoFocusType( CAS::EAutoFocusTypeOff );
 iAfHyperfocalPending = ETrue;
 }
 else
 {
 // If focustype is set to continuous, need to change it to off
 	  // before continuing
 PRINT( _L("Camera <> SetAutoFocusType( EAutoFocusTypeOff )") );
 if ( iAdvancedSettings->AutoFocusType() & CAS::EAutoFocusTypeContinuous )
 {
 iAdvancedSettings->SetAutoFocusType( CAS::EAutoFocusTypeOff );
 }
 PRINT( _L("Camera <> Cancel autofocus - set focus range to hyperfocal") );
 iInfo.iCurrentFocusRange = CAS::EFocusRangeHyperfocal;
 iAdvancedSettings->SetFocusRange( CAS::EFocusRangeHyperfocal );
 // Then start the focus. The callback of this cancel request sets
 // a boolean in CamAppController, so the resulting optimal
 // focus event does not change reticule/focus state.
 iAdvancedSettings->SetAutoFocusType( CAS::EAutoFocusTypeSingle );
 iAfInProgress = ETrue;
 }
 }
 else if( ECamRequestSetAfRange == aRequestId )
 {
 PRINT( _L("Camera <> Set autofocus range") );
 // Get autofocus mode from settings provider
 CAS::TFocusRange afRange;
 iSettingProvider.ProvideCameraSettingL( ECameraSettingFocusRange, &afRange );
 if( iInfo.iCurrentFocusRange != afRange )
 {
 iAdvancedSettings->SetFocusRange( afRange );
 // Should this be done in the callback?:
 iInfo.iCurrentFocusRange = afRange;
 }
 else
 {
 // Correct range already set. No need to do anything.
 }
 }
 else
 {
 // Other request must not end up here
 __ASSERT_DEBUG( EFalse, Panic( ECamCameraControllerCorrupt ) );
 }
 #endif // CAMERAAPP_CAPI_V2_ADV
 (void)aRequestId; // removes compiler warning
 PRINT( _L("Camera <= CCamCameraController::ProcessAutofocusRequestL") );
 }
 {
 PRINT ( _L("Camera => CCamCameraController::ProcessCaptureLimitSettingL") );
 #ifdef CAMERAAPP_CAPI_V2_ADV
 // Check that we are prepared for image mode.
 CheckFlagOnL( iInfo.iState, ECamImageOn, KErrNotReady );
 // Get requested capture count and determine current and target drive modes.
 TInt requestedLimit( 1 );
 iSettingProvider.ProvideCameraSettingL( ECameraSettingCaptureLimit, &requestedLimit );
 if( requestedLimit < 1 ) User::Leave( KErrArgument );
 const CAS::TDriveMode& currentMode( iAdvancedSettings->DriveMode() );
 const CAS::TDriveMode  targetMode ( requestedLimit <= 1
 ? CAS::EDriveModeSingleShot
 PRINT1( _L("Camera <> CCamCameraController .. target  drive mode       : [%S]"), &DriveModeName( targetMode  ) );
 PRINT ( _L("Camera <> CCamCameraController .. --------------------------------------") );
 // -------------------------------------------------------
 // Determine needed changes and when to issue them
 //
 // During burst capture, we may receive snapshots and
 // image data on mixed order, e.g:
 //
 //   [ ss#1 | img#1 | ss#2 | ss#3 | img2 | img3 ]
 //   --------------^^--------------------------^^
 //
 // C-API starts new burst capture when we adjust the
 // capture limit. To avoid problems and to get equal
 // amount of snapshots and images, capture count is
 // only changed when we image data is received,
 // and as many images as snapshots have arrived.
 // In the chart above ^ marks a place where capture limit
 // can be updated.
 TBool callback( EFalse );
 {
 // Cannot change drive mode during capturing.
 PRINT( _L("Camera <> CCamCameraController .. Drive mode update not possible now, LEAVE!") );
 User::Leave( KErrInUse );
 }
 else if ( CAS::EDriveModeBurst == currentMode )
 {
 if( cameraLimit != requestedLimit )
 {
 PRINT( _L("Camera <> CCamCameraController .. Adjusting capture limit during burst..") );
 // Set limit locally and react on next image data event.
 }
 else
 {
 // No action needed. Capture limit of 1 image kept.
 PRINT( _L("Camera <> CCamCameraController .. Single shot mode kept, no action") );
 }
 }
 // -----------------------------------
 // Not capturing
 //
 else
 {
 PRINT( _L("Camera <> CCamCameraController .. No capture ongoing..") );
 iInfo.iCaptureLimit = requestedLimit;
 // Capture limit has changed,
 // check if drive mode also needs to be changed..
 if( targetMode != currentMode )
 {
 PRINT1( _L("Camera <> CCamCameraController .. Calling SetDriveMode([%S])"), &DriveModeName( targetMode  ) );
 iAdvancedSettings->SetDriveMode( targetMode );
 iAdvancedSettings->SetBurstImages( iInfo.iCaptureLimit );
 }
 }
 // -------------------------------------------------------
 // Notify user that the change is done
 // or wait for camera callbacks to finish.
 PRINT1( _L("Camera <> CCamCameraController .. Should wait callback = %d"), callback );
 if( !callback )
 {
 TInt setting( ECameraSettingCaptureLimit );
 NotifyObservers( KErrNone,
 ECamCameraEventSettingsSingle,
 ECamCameraEventClassSettings,
 &setting );
 }
 #else
 // ---------------------------------------------------------------------------
 // EndSequence
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::EndSequence( TInt aStatus )
 {
 PRINT1( _L("Camera => CCamCameraController::EndSequence, status:%d"), aStatus );
 iIveRecoveryOngoing = EFalse;
 PRINT( _L("Camera <> ending sequence..") );
 ClearRequestQueue();
 iReserveTryAgainCount = KCamReserveTryAgainMaxCount;
 // Need to first clear busy flag as observer might issue
 // new requests in notification callback.
 ClearFlags( iInfo.iBusy, ECamBusySequence );
 PRINT( _L("Camera <> send notification..") );
 NotifyObservers( aStatus,
 ECamCameraEventSequenceEnd,
 ECamCameraEventClassBasicControl );
 }
 // -------------------------------------------------------
 else if( IsFlagOn( iInfo.iBusy, ECamBusySetting ) )
 {
 }
 }
 ClearSettingQueue();
 ClearFlags( iInfo.iBusy, ECamBusySetting );
 NotifyObservers( aStatus,
 ECamCameraEventSettingsDone,
 ECamCameraEventClassSettings,
 &last );
 }
 // -------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ClearRequestQueue()
 {
 iSequenceArray.Reset();
 iSequenceIndex = -1;
 }
 // ---------------------------------------------------------------------------
 // ClearSettingQueue
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ClearSettingQueue()
 {
 iSettingArray.Reset();
 iSettingIndex = -1;
 }
 OstTrace0( CAMERAAPP_PERFORMANCE, CCAMCAMERACONTROLLER_HANDLEPOWERONEVENT, "e_CAM_APP_INIT 0" );  //CCORAPP_APP_INIT_END
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMCAMERACONTROLLER_HANDLEPOWERONEVENT, "e_CAM_APP_VF_INIT 1" );  //CCORAPP_APP_VF_INIT_START
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMCAMERACONTROLLER_HANDLEPOWERONEVENT, "e_CAM_APP_CONFIGURATIONS 1" );   //CCORAPP_APP_CONFIGS_START
 OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMCAMERACONTROLLER_HANDLEPOWERONEVENT, "e_CAM_APP_STILL_INIT 1" );   //CCORAPP_APP_STILL_INIT_START
 CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
 if ( appUi->AppController().UiConfigManagerPtr()->IsFaceTrackingSupported() )
 {
 PRINT( _L("Camera <> CCamAppController: Get i/f MCameraFaceTracking..") )
 iCustomInterfaceFaceTracking =
 static_cast <MCameraFaceTracking*>(
 iCamera->CustomInterface( KCameraFaceTrackingUid ) );
 PRINT1( _L("Camera <> Face Tracking custom i/f pointer:%d"), iCustomInterfaceFaceTracking );
 }
 if( KErrNone == aStatus )
 {
 SetFlags( iInfo.iState, ECamPowerOn|ECamReserved );
 TRAP_IGNORE( SetFaceTrackingL() );
 #if defined( CAMERAAPP_CAE_FOR_VIDEO ) && !defined( CAMERAAPP_CAE_FIX )
 // We need to tell to CCaeEngine that the CCamera has been reserved
 // and powered on "behind its back".
 if( iCaeEngine )
 {
 iCaeEngine->EnableVideoRecording();
 }
 }
 else
 {
 PRINT( _L("Camera <> no mode change ongoing") );
 HandleCallbackEvent( aStatus,
 ECamCameraEventPowerOn,
 ECamCameraEventClassBasicControl );
 }
 #else
 HandleCallbackEvent( aStatus,
 ECamCameraEventPowerOn,
 ECamCameraEventClassBasicControl );
 #endif // CAMERAAPP_CAE_FIX
 if ( appUi->AppController().UiConfigManagerPtr()->IsOrientationSensorSupported() )
 {
 PRINT( _L("Camera <> CCamCameraController: Get i/f MCameraOrientation..") )
 if(!iCustomInterfaceOrientation )
 {
 iCustomInterfaceOrientation =
 static_cast <MCameraOrientation*>(
 iCamera->CustomInterface( KCameraOrientationUid ) );
 }
 PRINT1( _L("Camera <> Orientation custom i/f pointer:%d"), iCustomInterfaceOrientation );
 }
 PRINT( _L("Camera <= CCamCameraController::HandlePowerOnEvent") );
 }
 // ---------------------------------------------------------------------------
 // HandleReserveGainEvent
 }
 else
 {
 PRINT( _L("Camera <> no mode change ongoing") );
 HandleCallbackEvent( aStatus,
 ECamCameraEventReserveGain,
 ECamCameraEventClassBasicControl );
 }
 #else
 HandleCallbackEvent( aStatus,
 ECamCameraEventReserveGain,
 ECamCameraEventClassBasicControl );
 #endif // CAMERAAPP_CAE_FIX
 PRINT( _L("Camera <= CCamCameraController::HandleReserveGainEvent") );
 }
 {
 PRINT1( _L("Camera => CCamCameraController::HandleReserveLostEvent, status:%d"), aStatus );
 iInfo.iState   = ECamIdle;
 iInfo.iVfState = ECamTriIdle;
 iInfo.iSsState = ECamTriIdle;
 #pragma message("CCamCameraController: Reserve lost event does not stop sequence")
 // These are not valid anymore.
 ReleaseCustomInterfaces();
 }
 else
 #endif // CAMERAAPP_CAPI_V2
 {
 PRINT( _L("Camera <> no mode change ongoing") );
 NotifyObservers( aStatus,
 ECamCameraEventReserveLose,
 ECamCameraEventClassBasicControl );
 }
 #else // CAMERAAPP_CAE_FIX
 /*
 // We need to tell to CCaeEngine that the CCamera
 // has been released "behind its back".
 if( iCaeEngine )
 {
 iCaeEngine->DisableVideoRecording();
 }
 */
 #endif // CAMERAAPP_CAE_FIX
 // -------------------------------------------------------
 #else
 NotifyObservers( aStatus,
 ECamCameraEventReserveLose,
 ECamCameraEventClassBasicControl );
 // -------------------------------------------------------
 #endif // CAMERAAPP_CAE_FOR_VIDEO
 if ( !err && iIdle && !iIdle->IsActive() && // Recovering already
 iAppController.IsAppUiAvailable()  && // Exit mode
 iIveRecoveryCount &&                   // Give up eventually
 !appUi->AppInBackground( EFalse ) &&   // Only if on the foreground
 ( !iReleasedByUi ||             // Try recover if unknown reason
 appUi->StandbyStatus() ) &&    // or known error
 !iAppController.InVideocallOrRinging() && // Video telephony parallel use case
 !iIveRecoveryOngoing        //  processing recovery sequence
 )
 {
 PRINT( _L("Camera <> CCamCameraController::HandleReserveLostEvent - Start recovery") );
 NotifyObservers( aStatus,
 ECamCameraEventReserveLose,
 ECamCameraEventClassBasicControl );
 iIdle->Start( TCallBack( IdleCallback, this ) );
 }
 PRINT( _L("Camera <= CCamCameraController::HandleReserveLostEvent") );
 }
 // ---------------------------------------------------------------------------
 // HandleViewfinderEvent
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::HandleViewfinderEvent( MCameraBuffer* aCameraBuffer,
 TInt           aStatus )
 {
 PRINT_FRQ1( _L("Camera => CCamCameraController::HandleViewfinderEvent, status in:%d"), aStatus );
 CAMERAAPP_PERF_CONTROLLER_STOP_ONCE( ECamRequestVfStart, iFirstVfFrameReceived );
 {
 vfFrame = &(aCameraBuffer->BitmapL( 0 ));
 });
 PRINT_FRQ1( _L("Camera <> ..status after getting bitmap data: %d"), aStatus );
 }
 NotifyObservers( aStatus,
 ECamCameraEventVfFrameReady,
 ECamCameraEventClassVfData,
 vfFrame );
 ReleaseAndNull( aCameraBuffer );
 PRINT_FRQ( _L("Camera <= CCamCameraController::HandleViewfinderEvent") );
 // ---------------------------------------------------------------------------
 // HandleImageCaptureEvent
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::HandleImageCaptureEvent( MCameraBuffer* aCameraBuffer,
 TInt           aStatus )
 {
 PRINT1( _L("Camera => CCamCameraController::HandleImageCaptureEvent, status in: %d"), aStatus );
 // Check that we are expecting images..
 if( ECamCaptureOn == iInfo.iCaptureState )
 {
 // Store flags
 TUint busyFlags( iInfo.iBusy );
 // -----------------------------------------------------
 // Try to get the image data.
 if( KErrNone == aStatus )
 {
 // Takes ownership of aCameraBuffer and NULLs the pointer.
 TRAP( aStatus, HandleImageCaptureEventL( aCameraBuffer ) );
 PRINT1( _L("Camera <> status after handling data: %d"), aStatus );
 }
 // Release if not NULLed in HandleImageCaptureEventL.
 ReleaseAndNull( aCameraBuffer );
 // -----------------------------------------------------
 // Errors in or in handling
 iInfo.iCaptureState = ECamCaptureOff;
 // See HandleCallbackEvent for comments.
 // ClearFlags( iInfo.iBusy, ECamBusySingle );
 NotifyObservers( aStatus,
 ECamCameraEventImageData,
 ECamCameraEventClassImage );
 }
 // -----------------------------------------------------
 // If capture state was just changed to OFF,
 {
 // See HandleCallbackEvent for comments.
 ClearFlags( iInfo.iBusy, ECamBusySingle );
 TInt fullCaptures( Min( iInfo.iCaptureCount, iInfo.iSnapshotCount ) );
 NotifyObservers( aStatus,
 ECamCameraEventImageStop,
 ECamCameraEventClassImage,
 &fullCaptures );
 // Now we can actually continue, if necessary.
 if( IsFlagOn( busyFlags, ECamBusySequence ) )
 }
 else
 {
 PRINT( _L("Camera <> CCamCameraController ... [WARNING] Unexpected image data event!") );
 iInfo.PrintInfo();
 // Stop capture to be safe.
 PRINT( _L("Camera <> CCamCameraController ... Calling CancelCaptureImage..") );
 iCamera->CancelCaptureImage();
 // Not expecting image data at this time.
 share->Reserve();
 CleanupStack::PushL( TCleanupItem( CamBufferShareCleanup, share ) );
 PRINT( _L("Camera <> CCamCameraController .. Checking encoded data availability..") );
 TRAPD( dataStatus,
 {
 TDesC8* data = share->SharedBuffer()->DataL( 0 );
 if( !data )
 User::Leave( KErrNotFound );
 });
 // -------------------------------------------------------
 // Normal capture format case
 // Increase received images count. Needed in burst drive mode.
 iInfo.iCaptureCount++;
 PRINT1( _L("Camera <> CCamCameraController ... Incremented capture counter to: %d"), iInfo.iCaptureCount );
 // If we have needed amount of snapshots and images, end capture.
 if( iInfo.iCaptureCount  >= iInfo.iCaptureLimit
 && ( (iInfo.iSnapshotCount >= iInfo.iCaptureLimit) || iInfo.iSsState != ECamTriActive ) )
 {
 PRINT( _L("Camera <> CCamCameraController ... Capture limit met, calling CancelCaptureImage..") );
 iCamera->CancelCaptureImage();
 }
 #ifdef CAMERAAPP_CAPI_V2_ADV
 // If we are in burst mode and need to increase capture limit,
 // do it now. If we have just decreased the capture limit,
 // we just cancel once the limit is met.
 else if( iAdvancedSettings
 && iAdvancedSettings->DriveMode() == CAS::EDriveModeBurst )
 {
 const TInt cameraLimit( iAdvancedSettings->BurstImages() );
 PRINT1( _L("Camera <> CCamCameraController ... Camera capture limit: %d"), cameraLimit         );
 }
 // See HandleCallbackEvent for comments.
 // ClearFlags( iInfo.iBusy, ECamBusySingle );
 NotifyObservers( KErrNone,
 ECamCameraEventImageData,
 ECamCameraEventClassImage,
 share );
 }
 // -------------------------------------------------------
 // Bitmap format case. Need to encode first.
 else if( iAlternateFormatInUse )
 // Check that we are in right state to handle snapshot.
 // CCameraSnapshot sends atleast event with KErrCancel status
 // when releasing the camera.
 TBool videoSsExpected( IsFlagOn( iInfo.iState, ECamVideoOn ) );
 TBool imageSsExpected( IsFlagOn( iInfo.iState, ECamImageOn )
 && ECamCaptureOn        == iInfo.iCaptureState
 && iInfo.iSnapshotCount <  iInfo.iCaptureLimit );
 if(
 #ifdef CAMERAAPP_CAE_FIX
 ECamModeChangeInactive == iModeChange &&
 #endif
 (videoSsExpected||imageSsExpected)
 )
 if( KErrNone == aStatus )
 {
 TRAP( aStatus, HandleSnapshotEventL() );
 PRINT1( _L("Camera <> CCamCameraController ... status after handling snapshot data: %d"), aStatus );
 }
 // -----------------------------------------------------
 // If snapshot was received and notified ok,
 // check if capture ended.
 if( KErrNone == aStatus )
 {
 // If we have needed amount of snapshots and images, end capture.
 if( iInfo.iCaptureCount  >= iInfo.iCaptureLimit
 && iInfo.iSnapshotCount >= iInfo.iCaptureLimit )
 {
 PRINT( _L("Camera <> CCamCameraController ... Setting capture state to OFF..") );
 iInfo.iCaptureState = ECamCaptureOff;
 }
 // -----------------------------------------------------
 // If any error, stop capture.
 else
 {
 PRINT( _L("Camera <> CCamCameraController ... error encountered, notify and set capture state off..") );
 NotifyObservers( aStatus,
 ECamCameraEventSsReady,
 ECamCameraEventClassSsData );
 iInfo.iCaptureState = ECamCaptureOff;
 }
 // -----------------------------------------------------
 {
 // See HandleCallbackEvent for comments.
 ClearFlags( iInfo.iBusy, ECamBusySingle );
 TInt fullCaptures( Min( iInfo.iCaptureCount, iInfo.iSnapshotCount ) );
 NotifyObservers( aStatus,
 ECamCameraEventImageStop,
 ECamCameraEventClassImage,
 &fullCaptures );
 }
 // -----------------------------------------------------
 }
 if( iInfo.iSnapshotCount > iInfo.iCaptureLimit )
 {
 // For burst stopping:
 //   We have more snapshots already than requested..
 //   All needed captures have to have started,
 //   so we can call cancel here.
 // Note:
 //   Cannot use ">=" as last image might not be provided then.
 //
 PRINT( _L("Camera <> CCamCameraController ... Snapshot limit passed, calling CancelCaptureImage..") );
 iCamera->CancelCaptureImage();
 }
 PRINT( _L("Camera <> CCamCameraController ... [WARNING] Snapshot ignored!") );
 // HandleSnapshotEventL
 //
 // Helper method for leaving part of HandleSnapshotEvent.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::HandleSnapshotEventL( TBool aIgnore )
 {
 PRINT1( _L("Camera => CCamCameraController::HandleSnapshotEventL ignore %d"),aIgnore);
 __ASSERT_DEBUG( iSnapshotProvider, Panic( ECamCameraControllerCorrupt ) );
 RArray<TInt> temp;
 TInt firstImageIndex = temp.Find( 0 );
 CleanupStack::PopAndDestroy(); // temp.Close()
 if( !aIgnore )
 {
 CleanupStack::PushL( TCleanupItem( CameraBufferCleanup, buffer ) );
 CFbsBitmap& snapshot = buffer->BitmapL( firstImageIndex );
 PRINT2( _L("Camera <> CCamCameraController ... snapshot size: (%dx%d)"),
 snapshot.SizeInPixels().iWidth, snapshot.SizeInPixels().iHeight );
 // Increase received snapshots count.
 // Needed in burst drive mode.
 iInfo.iSnapshotCount++;
 ECamCameraEventClassSsData,
 &snapshot );
 CleanupStack::PopAndDestroy(); // buffer->Release()
 }
 else
 {
 ReleaseAndNull(buffer);
 }
 PRINT( _L("Camera <= CCamCameraController::HandleSnapshotEventL"));
 }
 // ---------------------------------------------------------------------------
 // HandleVideoInitEvent
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::HandleVideoEvent( const TCamCameraEventId& aEventId,
 TInt               aStatus   )
 {
 PRINT2( _L("Camera => CCamCameraController::HandleVideoEvent, status:%d, event[%s]"),
 aStatus,
 KCamCameraEventNames[aEventId] );
 // Only video stop of these events may come without our explicit request.
 /*
 if( ECamCameraEventVideoStop != aEventId )
 {
 if( ECamBusyOff != iInfo.iBusy )
 CAMERAAPP_PERF_CONTROLLER_STOP( ECamRequestVideoInit );
 if( KErrNone == aStatus ) SetFlags  ( iInfo.iState, ECamVideoOn );
 else                      ClearFlags( iInfo.iState, ECamVideoOn );
 }
 #ifdef CAMERAAPP_CAPI_V2_ADV
 TRAP_IGNORE( GetAdvancedSettingsInfoL() );
 #endif
 #ifdef CAMERAAPP_CAE_FIX
 if( ECamModeChangeImage2Video == iModeChange )
 {
 iModeChangeStatus = aStatus;
 }
 #endif // CAMERAAPP_CAE_FIX
 break;
 // -----------------------------------------------------
 case ECamCameraEventVideoStart:
 if( KErrNone == aStatus )
 {
 iInfo.iCaptureState = ECamCaptureOn;
 }
 break;
 // -----------------------------------------------------
 case ECamCameraEventVideoPause:
 if( KErrNone == aStatus )
 {
 iInfo.iCaptureState = ECamCapturePaused;
 }
 else
 {
 // Even if error we have done what we can for stopping.
 // Update internal capture state anyway.
 iInfo.iCaptureState = ECamCaptureOff;
 // We may receive this event from CCaeEngine, even though we have not
 // issued a request to stop the video recording. If e.g. there is not
 // enough space in the disk to continue recording, this event is
 // generated without explicit request.
 //
 // We must not continue any pending operations if this event is not
 // a response to our stop request.
 // HandleCallbackEvent takes care of that.
 break;
 // -----------------------------------------------------
 case ECamCameraEventVideoAsyncStop:
 PRINT( _L("Camera <> CCamCameraController::HandleVideoEvent case ECamCameraEventVideoAsyncStop") );
 break;
 }
 // -----------------------------------------------------
 }
 HandleCallbackEvent( aStatus,
 aEventId,
 ECamCameraEventClassVideo );
 PRINT( _L("Camera <= CCamCameraController::HandleVideoEvent") );
 }
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 // ---------------------------------------------------------------------------
 // HandleVideoTimeEvent
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController
 ::HandleVideoTimeEvent( TInt aStatus,
 TTimeIntervalMicroSeconds aTimeElapsed,
 TTimeIntervalMicroSeconds aTimeRemaining )
 {
 // If capture has already stopped, we don't echo this to our observers.
 if( ECamCaptureOff != iInfo.iCaptureState )
 {
 iVideoTimes.iTimeElapsed   = aTimeElapsed.Int64();
 iVideoTimes.iTimeRemaining = aTimeRemaining.Int64();
 NotifyObservers( aStatus,
 ECamCameraEventVideoTimes,
 ECamCameraEventClassVideoTimes,
 &iVideoTimes );
 }
 }
 #endif
 // ---------------------------------------------------------------------------
 // HandleAutoFocusEvent
 //
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::HandleAutoFocusEvent( TInt aStatus, const TUid& aEventUid )
 {
 PRINT1( _L("Camera => CCamCameraController::HandleAutoFocusEvent, status: %d"), aStatus );
 TBool proceed = EFalse;
 // -------------------------------------------------------
 // Check the event
 if( KUidECamEventCameraSettingsOptimalFocus == aEventUid )
 {
 PRINT( _L("Camera <> CCamCameraController: event KUidECamEventCameraSettingsOptimalFocus") );
 if( !iAfHyperfocalPending )
 {
 iFirstAfEventReceived = EFalse;
 }
 }
 else if( KUidECamEventCameraSettingAutoFocusType2 == aEventUid )
 {
 PRINT( _L("Camera <> CCamCameraController: event KUidECamEventCameraSettingsAutoFocusType2") );
 // If AF started and canceled before finishing
 if( iAfInProgress && iAfHyperfocalPending && iFirstAfEventReceived )
 {
 // continue to set focus to hyperfocal
 proceed = ETrue;
 }
 if( !iFirstAfEventReceived )
 {
 // For the first time, this event means that the autofocusing has been started
 iFirstAfEventReceived = ETrue;
 PRINT( _L("Camera <> CCamCameraController: event KUidECamEventCameraSettingAutoFocusType2 - first time, set iFirstAfEventReceived ") );
 }
 else
 {
 iFirstAfEventReceived = EFalse;
 PRINT( _L("Camera <> CCamCameraController: event KUidECamEventCameraSettingAutoFocusType2 - second time") );
 }
 }
 else
 {
 // No other event acceptable here..
 __ASSERT_DEBUG( EFalse, Panic( ECamCameraControllerCorrupt ) );
 {
 TCamCameraEventId  event = ( KErrNone == aStatus )
 ? ECamCameraEventAutofocusSuccessful
 : ECamCameraEventAutofocusFailed;
 if( iAfHyperfocalPending )
 {
 PRINT( _L("Camera <> Cancelled active autofocus request.") );
 PRINT( _L("Camera <> Setting focus range to hyperfocal, no event to observers yet") );
 iAfHyperfocalPending = EFalse;
 iAfInProgress = EFalse;
 TRAP_IGNORE( ProcessAutofocusRequestL( ECamRequestCancelAutofocus ) );
 }
 else
 {
 HandleCallbackEvent( KErrNone,
 event,
 ECamCameraEventClassAutofocus );
 }
 }
 else if(iFirstAfEventReceived && (aStatus != KErrNone) )
 {
 //There might have been error when first event was received
 //and no further autofocus events would occur.
 iFirstAfEventReceived = EFalse;
 iAfInProgress = EFalse;
 if( iAfHyperfocalPending )
 {
 PRINT( _L("Camera <> Cancelled active autofocus request.") );
 PRINT( _L("Camera <> Set focus range to hyperfocal, no event to observers yet") );
 iAfHyperfocalPending = EFalse;
 TRAP_IGNORE( ProcessAutofocusRequestL( ECamRequestCancelAutofocus ) );
 }
 else
 {
 HandleCallbackEvent( KErrNone,
 ECamCameraEventAutofocusFailed,
 ECamCameraEventClassAutofocus );
 }
 }
 // -------------------------------------------------------
 PRINT( _L("Camera <= CCamCameraController::HandleAutoFocusEvent") );
 }
 // ---------------------------------------------------------------------------
 //
 // HandleFlashStatusEvent
 //
 // Helper method to handle flash status updates.
 //
 // ---------------------------------------------------------------------------
 void
 CCamCameraController::HandleFlashStatusEvent( TInt                     aStatus,
 const TCamCameraEventId& aEventId )
 {
 PRINT2( _L("Camera => CCamCameraController::HandleFlashStatusEvent, event[%s] status:%d"), KCamCameraEventNames[aEventId], aStatus );
 NotifyObservers( aStatus,
 aEventId,
 EventClass( aEventId ) );
 PRINT ( _L("Camera <= CCamCameraController::HandleFlashStatusEvent" ) );
 }
 // ---------------------------------------------------------------------------
 // Notifies observers and checks if we should proceed with the sequence.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController
 ::HandleCallbackEvent(       TInt                    aStatus,
 const TCamCameraEventId&      aEventId,
 const TCamCameraEventClassId& aEventClass,
 TAny*                   aEventData /*= NULL*/ )
 {
 PRINT1( _L("Camera => CCamCameraController::HandleCallbackEvent, event[%s]"),
 KCamCameraEventNames[aEventId] );
 // -------------------------------------------------------
 // Clear single request busy flag before notification to observers,
 // in case client wishes to issue new request during the notification.
 // Sequence busy flag can only be cleared in EndSequence
 ClearFlags( iInfo.iBusy, ECamBusySingle );
 // Observers might issue a new sequence during notification.
 // We need to decide if sequence needs to continue here
 // based on the status *before* notification.
 TBool proceedSequence = EFalse;
 TBool notify          = ETrue;
 // -------------------------------------------------------
 // 1) Processing sequence is ongoing.
 // 2) The received event is exact response to our request.
 //    There are events like "video stopped" or "reserve lost"
 //    that may be received without our associated request.
 //    In that case we must not proceed sequence processing now.
 // 3) In case that aStatus is KErrInUse and the current event is
 //    Reserve, it means reserve failed for some reason
 if( IsFlagOn( iInfo.iBusy, ECamBusySequence ) ) // 1
 {
 PRINT( _L("Camera <> Sequence is active") );
 PRINT2( _L("Camera <> seq index: %d, seq array len: %d"), iSequenceIndex, iSequenceArray.Count() );
 if( KErrNone != aStatus )
 {
 if ( KErrInUse == aStatus               // 3
 && aEventId == ECamCameraEventReserveGain
 && iSequenceIndex >= 0
 && Request2Event( iSequenceArray[iSequenceIndex] ) == ECamCameraEventReserveGain
 && iReserveTryAgainCount > 0 )
 {
 // Handle here only if reserve gain with error is part of a sequence and try again count is not zero
 iReserveTryAgainCount--;
 User::After( KCamReserveTryAgainWaitInterval );
 // decrease index, to get the same request handled again
 iSequenceIndex--;
 notify          = EFalse;
 proceedSequence = ETrue;
 PRINT1( _L( "Camera <> CCamCameraController::HandleCallbackEvent - %d reserve try again left" ), iReserveTryAgainCount );
 }
 else
 {
 notify          = EFalse;
 proceedSequence = EFalse;
 EndSequence( aStatus );
 }
 }
 else if( iSequenceIndex >= 0 &&  // Sequence has started
 Request2Event( iSequenceArray[iSequenceIndex] ) == aEventId ) // 2
 {
 notify          = ETrue;
 proceedSequence = ETrue;
 }
 else
 {
 // Not the event we need yet.
 }
 }
 // -------------------------------------------------------
 // Setting sequence ongoing
 else if( IsFlagOn( iInfo.iBusy, ECamBusySetting )
 && iSettingIndex >= 0 )
 {
 PRINT( _L("Camera <> Settings change ongoing..") );
 // Default is no notification
 {
 PRINT( _L("Camera <> error in, end settings sequence!") );
 proceedSequence = EFalse;
 EndSequence( aStatus ); // does one notification
 }
 else if( ECamCameraEventSettingsSingle == aEventId
 && aEventData
 && iSettingArray[iSettingIndex] == *( static_cast<TInt*>( aEventData ) )
 )
 {
 // We have checked already in HandleEvent that this is
 // the right event for the setting we wait to finish.
 // Notification can be sent with the given data.
 PRINT( _L("Camera <> One setting finished, continue sequence") );
 proceedSequence = ETrue;
 }
 // Video init event repeated when filename or max file size set
 // after init already done
 else if( IsFlagOn( iInfo.iState, ECamVideoOn )
 && ECamCameraEventVideoInit == aEventId
 && ( ECameraSettingFileName    == iSettingArray[iSettingIndex]
 || ECameraSettingFileMaxSize == iSettingArray[iSettingIndex]
 || ECameraSettingAudioMute   == iSettingArray[iSettingIndex] ) )
 {
 PRINT( _L("Camera <> One setting finished, continue sequence") );
 proceedSequence = ETrue;
 // -------------------------------------------------------
 // Notify the observers with data from the event.
 if( notify )
 {
 NotifyObservers( aStatus, aEventId, aEventClass, aEventData );
 }
 // -------------------------------------------------------
 // If this is part of sequence, continue processing.
 if( proceedSequence )
 // ---------------------------------------------------------------------------
 // Notify all our observers of an event.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController
 ::NotifyObservers( TInt                   aStatus,
 TCamCameraEventId      aEventId,
 TCamCameraEventClassId aEventClass,
 TAny*                  aEventData /*=NULL*/ )
 {
 //  PRINT ( _L("Camera => CCamCameraController::NotifyObservers") );
 //  PRINT3( _L("Camera <> status:% 3d event:% 3d class:%032b"), aStatus, aEventId, aEventClass );
 // NOTE:
 //   We might skip an observer, if during the notification some observer
 //   is removed from the array (from smaller index than current one).
 //   This is a commmon problem for all observable classes in this application.
 for( TInt i = 0; i < iObservers.Count(); i++ )
 {
 // Observer defines which events it is interested in.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::ReleaseCurrentCamera()
 {
 PRINT( _L("Camera => CCamCameraController::ReleaseCurrentCamera") );
 // Cancel any outstanding sequence.
 if( IsFlagOn( iInfo.iBusy, ECamBusySequence )
 #ifdef CAMERAAPP_CAE_FIX
 // Mode change calls this method possibly in the middle
 // of request sequence. Must not try to cancel then.
 CancelSequence();
 }
 if( IsFlagOn( iInfo.iState, ECamReserved ) )
 {
 // Releases viewfinder and snapshot, cancels capture,
 // powers off and releases CCamera if needed.
 ProcessControlShutdownRequest( ECamRequestRelease );
 }
 // Custom interfaces (not owned)
 iInfo.Reset();
 #endif
 iResolutionSupport.Reset();
 iInfo.iState = ECamIdle;
 PRINT( _L("Camera <= CCamCameraController::ReleaseCurrentCamera") );
 }
 // ---------------------------------------------------------------------------
 // ReleaseCustomInterfaces
 // ---------------------------------------------------------------------------
 // GetResolutionIndexL
 //
 // Get quality index for prepare with given format and size.
 // If current info is not for the given format, update the
 // supported resolutions info. After the support info is up to date,
 // find the index. Return KErrNotFound if not supported size.
 //
 // For JPEG format we try two alternate bitmap formats, if
 // the given resolution is not supported in JPEG format.
 // Reset all old resolution info
 iResolutionSupport.Reset();
 // Get the resolution info for current camera with given format.
 const TInt KResolutionCount( iCameraInfo.iNumImageSizesSupported );
 RArray<TSize>& resolutions( iResolutionSupport.iResolutions );
 resolutions.ReserveL( KResolutionCount );
 for( TInt i = 0; i < KResolutionCount; i++ )
 {
 // Reserve called, so should not leave.
 resolutions.AppendL( TSize() );
 iCamera->EnumerateCaptureSizes( resolutions[i], i, aFormat );
 }
 // Set these after successful filling of the array
 PRINT1( _L("Camera <> EFormatFbsBitmapColor16M : %032b"  ), CCamera::EFormatFbsBitmapColor16M  );
 PRINT1( _L("Camera <> EFormatFbsBitmapColor16MU: %032b"  ), CCamera::EFormatFbsBitmapColor16MU );
 for( TInt i = 0; i < iResolutionSupport.iResolutions.Count(); i++ )
 {
 const TSize& size( iResolutionSupport.iResolutions[i] );
 PRINT3( _L("Camera <> Size (%d): (%d,%d)"), i, size.iWidth, size.iHeight );
 }
 PRINT ( _L("Camera <> ==================================================") );
 #endif
 TIdentityRelation<TSize> compareFunc( CCamCameraController::CompareSize );
 // Exception for JPEG format:
 //   If JPEG format is not supported, but bitmap format is,
 //   pretend to support the format anyway.
 //   When capturing, we encode the JPEG from the bitmap.
 if( CCamera::EFormatJpeg == aFormat
 && KErrNotFound         == index )
 {
 PRINT ( _L("Camera <> Jpeg not supported, trying bitmap format 1..") );
 aFormat = KCamJpegAlternativeFormat1;
 index   = GetResolutionIndexL( aFormat, aSize );
 if( KErrNotFound == index )
 //
 void
 CCamCameraController::GetAdvancedSettingsInfoL()
 {
 PRINT ( _L("Camera => CCamCameraController::GetAdvancedSettingsInfoL") );
 PRINT2( _L("Camera <> current camera:%d, latest info for:%d"),
 iInfo.iCurrentCamera,
 iAdvancedSettingInfo.iForCameraIndex );
 CheckNonNullL( iAdvancedSettings, KErrNotReady );
 iAdvancedSettingInfo.Reset();
 TInt             index ( GetResolutionIndexL( format, params().iSize ) );
 User::LeaveIfError( index );
 TBool isInfluencePossible; // Not used
 PRINT( _L("Camera <> Get zoom steps for image") );
 TRAP( error, iAdvancedSettings->GetDigitalZoomStepsForStillL (
 iAdvancedSettingInfo.iDigitalZoomSupport,
 iAdvancedSettingInfo.iDigitalZoomValueInfo,
 index,
 format,
 isInfluencePossible  ) );
 if( KErrNotSupported != error ) User::LeaveIfError( error );
 }
 else if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 {
 PRINT( _L("Camera <> Get zoom steps for video") );
 TRAP( error, iAdvancedSettings->GetDigitalZoomStepsL(
 iAdvancedSettingInfo.iDigitalZoomSupport,
 iAdvancedSettingInfo.iDigitalZoomValueInfo ) );
 if( KErrNotSupported != error ) User::LeaveIfError( error );
 }
 // -----------------------------------------------------
 // EV steps multiplied by KECamFineResolutionFactor.
 PRINT( _L("Camera <> Get EV support..") );
 iAdvancedSettingInfo.iEvModesSupport =
 iAdvancedSettings->SupportedExposureModes();
 TRAP( error, iAdvancedSettings->GetExposureCompensationStepsL(
 iAdvancedSettingInfo.iEvStepsSupport,
 iAdvancedSettingInfo.iEvStepsValueInfo ) );
 // Ignore error if just not supported.
 // We check the support when setting is requested.
 if( KErrNotSupported != error ) User::LeaveIfError( error );
 // -----------------------------------------------------
 // ISO rates (.. 50, 100, 200, ..)
 PRINT( _L("Camera <> Get ISO rates..") );
 TRAP( error, iAdvancedSettings->GetSupportedIsoRatesL(
 iAdvancedSettingInfo.iIsoRatesSupport ) );
 if( KErrNotSupported != error ) User::LeaveIfError( error );
 // -----------------------------------------------------
 // Stabilization
 PRINT( _L("Camera <> Get Stabilization info..") );
 iAdvancedSettingInfo.iStabilizationModeSupport =
 iAdvancedSettings->SupportedStabilizationModes();
 iAdvancedSettingInfo.iStabilizationEffectSupport =
 iAdvancedSettings->SupportedStabilizationEffects();
 iAdvancedSettingInfo.iStabilizationComplexitySupport =
 iAdvancedSettings->SupportedStabilizationComplexityValues();
 // -----------------------------------------------------
 #ifdef CAMERAAPP_CAPI_V2_IP
 // Image Processor only for primary camera
 if( KPrimaryCameraIndex == iInfo.iCurrentCamera )
 {
 PRINT( _L("Camera <> Get image processing info..") );
 if( iImageProcessor != NULL )
 {
 // -----------------------------------------------------
 PRINT( _L("Camera <> Get sharpness support..") );
 TRAP( error, iImageProcessor->GetTransformationSupportedValuesL(
 KUidECamEventImageProcessingAdjustSharpness,
 iAdvancedSettingInfo.iSharpnessSupport,
 iAdvancedSettingInfo.iSharpnessValueInfo ) );
 if( KErrNotSupported != error ) User::LeaveIfError( error );
 // -----------------------------------------------------
 PRINT( _L("Camera <> Get colour effect support..") );
 TRAP( error, iImageProcessor->GetTransformationSupportedValuesL(
 KUidECamEventImageProcessingEffect,
 iAdvancedSettingInfo.iColourEffectSupport,
 iAdvancedSettingInfo.iColourEffectValueInfo ) );
 if( KErrNotSupported != error ) User::LeaveIfError( error );
 }
 else
 {
 PRINT( _L("Camera <> [WARNING] Image processing not supported") );
 }
 }
 #endif // CAMERAAPP_CAPI_V2_IP
 // -----------------------------------------------------
 PRINT( _L("Camera <> ..done") );
 iAdvancedSettingInfo.iForCameraIndex = iInfo.iCurrentCamera;
 #ifdef _DEBUG
 iAdvancedSettingInfo.PrintInfo();
 #endif
 PRINT ( _L("Camera <= CCamCameraController::GetAdvancedSettingsInfoL") );
 }
 // ---------------------------------------------------------------------------
 // ResolveEvStep
 //
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController::ResolveEvStep( TInt aEvProposedStep ) const
 {
 PRINT1( _L("Camera => CCamCameraController::ResolveEvStep( %d )"), aEvProposedStep );
 TInt delta ( KMaxTInt );
 // ---------------------------------------------------------------------------
 // IsSupportedValue <<static>>
 // ---------------------------------------------------------------------------
 //
 TBool
 CCamCameraController::IsSupportedValue( const TInt&         aValue,
 const RArray<TInt>& aValueList,
 const TValueInfo&   aValueInfo )
 {
 TBool support( EFalse );
 switch( aValueInfo )
 // Compare the support bitfield and the setting value.
 // Default value for these settings is zero (0) and
 // that is always supported.
 // Array: [0] bitfield of supported bits
 support = ( 1 <= aValueList.Count()
 && ( !aValue
 || (aValue & aValueList[0]) // 0 always supported
 )
 );
 break;
 }
 {
 // Support is described by min and max value,
 // continuous range of values within those two is supported.
 // Array: [0] min supported value
 //        [1] max supported value
 support =
 ( 2      <= aValueList.Count() // We need 2 items.
 && aValue >= aValueList[0]      // aValue >= min
 && aValue <= aValueList[1]      // aValue <= max
 );
 break;
 ::ResolveSnapshotFormatL( CCamera::TFormat aPreferredFormat ) const
 {
 PRINT ( _L("Camera => CCamCameraController::ResolveSnapshotFormatL") );
 CheckNonNullL( iSnapshotProvider, KErrNotReady );
 const TUint32    support = iSnapshotProvider->SupportedFormats();
 CCamera::TFormat final   = aPreferredFormat;
 // Return the preferred format if it is supported.
 // Otherwise return the "best" supported format.
 if      ( support & aPreferredFormat                   ) final = aPreferredFormat;
 else if ( support & CCamera::EFormatFbsBitmapColor16MU ) final = CCamera::EFormatFbsBitmapColor16MU;
 else if ( support & CCamera::EFormatFbsBitmapColor16M  ) final = CCamera::EFormatFbsBitmapColor16M;
 {
 // No known acceptable format supported
 PRINT( _L("Camera <> CCamCameraController: No acceptable format available, LEAVE!") );
 User::Leave( KErrNotSupported );
 }
 PRINT1( _L("Camera <> Preferred format : %032b"), aPreferredFormat  );
 PRINT1( _L("Camera <> Supported formats: %032b"), support           );
 PRINT1( _L("Camera <> Selected  format : %032b"), final             );
 PRINT ( _L("Camera <= CCamCameraController::ResolveSnapshotFormatL") );
 return final;
 case ECamRequestVideoStop:     return ECamCameraEventVideoStop;
 case ECamRequestVideoRelease:  return ECamCameraEventVideoRelease;
 // -----------------------------------------------------
 // Autofocus
 case ECamRequestStartAutofocus:   return ECamCameraEventStartAutofocus;
 case ECamRequestCancelAutofocus:  return ECamCameraEventCancelAutofocus;
 case ECamRequestSetAfRange:       return ECamCameraEventSetAfRange;
 // -----------------------------------------------------
 // Unrecognised
 default:
 {
 Panic( ECamCameraControllerUnknownRequest );
 return ECamCameraEventNone;
 }
 // -----------------------------------------------------
 }
 }
 // ---------------------------------------------------------------------------
 // EventClass <<static>>
 case ECamCameraEventVfStart:
 case ECamCameraEventVfStop:
 case ECamCameraEventVfRelease:
 return ECamCameraEventClassVfControl;
 // -------------------------------------------------------
 case ECamCameraEventVfFrameReady:
 return ECamCameraEventClassVfData;
 // -------------------------------------------------------
 case ECamCameraEventSsStart:
 case ECamCameraEventSsStop:
 case ECamCameraEventSsRelease:
 return ECamCameraEventClassSsControl;
 // -------------------------------------------------------
 case ECamCameraEventSsReady:
 return ECamCameraEventClassSsData;
 // -------------------------------------------------------
 case ECamCameraEventImageInit:
 case ECamCameraEventImageStart:
 case ECamCameraEventImageStop:
 case ECamCameraEventVideoStop:
 case ECamCameraEventVideoRelease:
 return ECamCameraEventClassVideo;
 // -------------------------------------------------------
 case ECamCameraEventVideoTimes:
 return ECamCameraEventClassVideoTimes;
 // -------------------------------------------------------
 case ECamCameraEventSettingsSingle:
 case ECamCameraEventSettingsDone:
 return ECamCameraEventClassSettings;
 // -------------------------------------------------------
 case ECamCameraEventFlashNotReady:
 return ECamCameraEventClassFlashStatus;
 // -------------------------------------------------------
 default:
 {
 #ifdef _DEBUG
 Panic( ECamCameraControllerCorrupt );
 #endif
 return ECamCameraEventClassAll;
 }
 }
 // ---------------------------------------------------------------------------
 // CurrentSettingHasCallback
 // ---------------------------------------------------------------------------
 //
 TBool
 CCamCameraController::CurrentSettingHasCallback()
 {
 TBool callback( EFalse );
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 #ifdef CAMERAAPP_CAE_FOR_VIDEO
 // ---------------------------------------------------------------------------
 // NewCaeEngineL
 // ---------------------------------------------------------------------------
 //
 CCaeEngine*
 CCamCameraController::NewCaeEngineL( TInt aCameraIndex )
 {
 PRINT( _L("Camera => CCamCameraController::NewCaeEngineL") );
 #ifndef FORCE_DUMMY_ENGINE
 CCaeEngine* engine = CCaeEngine::NewL( aCameraIndex );
 #else
 (void)aCameraIndex; // remove compiler warning
 CCaeEngine* engine = CCameraappDummyEngine::NewL();
 #endif
 engine->SetCamAppEngineObserver( *this );
 PRINT( _L("Camera <= CCamCameraController::NewCaeEngineL") );
 return engine;
 }
 // ---------------------------------------------------------------------------
 // NewCameraL
 // ---------------------------------------------------------------------------
 //
 CAMERA*
 CCamCameraController::NewCameraL( TInt aCameraIndex )
 {
 PRINT( _L("Camera => CCamCameraController::NewCameraL") );
 CAMERA* camera( NULL );
 #ifdef CAMERAAPP_CAPI_V2
 camera = CAMERA::New2L( *this, aCameraIndex, KCameraClientPriority );
 #else
 // Both v1 and v2 observer interface implemented
 // Need to cast to avoid ambiguous call.
 MCameraObserver* self( this );
 PRINT1( _L("Camera <> Give observer pointer: %d"), self );
 camera = CAMERA::NewL ( *self, aCameraIndex );
 #endif // CAMERAAPP_CAPI_V2
 PRINT( _L("Camera <= CCamCameraController::NewCameraL") );
 return camera;
 }
 // ---------------------------------------------------------------------------
 // NewDuplicateCameraL
 // ---------------------------------------------------------------------------
 //
 CAMERA*
 CCamCameraController::NewDuplicateCameraL( TInt aCameraHandle )
 {
 PRINT1( _L("Camera => CCamCameraController::NewDuplicateCameraL( %d )"), aCameraHandle );
 CAMERA* camera( NULL );
 // ---------------------------------------------------------------------------
 // 1st phase constructor
 // ---------------------------------------------------------------------------
 //
 CCamCameraController
 ::CCamCameraController( MCamSettingProvider& aSettingProvider,
 CCamAppController& aAppController )
 : iSequenceArray       ( KCamSequenceGranularity     ),
 iReserveTryAgainCount( KCamReserveTryAgainMaxCount ),
 iSettingProvider     ( aSettingProvider            ),
 iAppController       ( aAppController              )
 {
 }
 // ===========================================================================
 // Workaround for CCaeEngine with no support for CCamera sharing
 TInt
 CCamCameraController::ProceedModeSwitch()
 {
 PRINT1( _L("Camera => CCamCameraController::ProceedModeSwitch, status in:%d"), iModeChangeStatus );
 TInt proceed( EFalse );
 // Update only after here, so any events arriving
 // in the middle get ignored if wanted.
 ++iModeChangePhase;
 if( KErrNone == iModeChangeStatus )
 {
 TRAP( iModeChangeStatus, proceed = DoProceedModeSwitchL() );
 }
 //        iSettingProvider.ProvideCameraSettingL( ECameraSettingFileName, &ptr );
 _LIT( KTempFilename, "C:\\video.3gp" );
 TPtrC ptr;
 ptr.Set( KTempFilename() );
 #pragma message( "Camera Controller: video filename hardcoded" )
 PRINT1( _L("Camera <> Set filename [%S]"), &ptr );
 iCaeEngine->SetVideoRecordingFileNameL( ptr );
 //        CleanupStack::PopAndDestroy( filename );
 // Set max video clip size
 ProcessSettingL( ECameraSettingFileMaxSize );
 TPckgBuf<TCamParamsVideoCae> params;
 iSettingProvider.ProvideCameraParamL( ECameraParamVideoCae, &params );
 // The audioOn value is defined On==0 and Off==1, but the engine expects
 // ETrue if audio recording is On
 params().iAudioOn = ( ECamSettOn == params().iAudioOn )
 											? ETrue
 											: EFalse;
 PRINT( _L("Camera <> Call prepare..") );
 // McaeoVideoPrepareComplete will be called when prepare is ready.
 // The callback is allowed to come also *during* this call.
 iCaeEngine->PrepareVideoRecordingL( params().iFrameSize,
 params().iFrameRate,
 PRINT( _L("Camera <> Phase3: Notifying..") );
 iModeChange      = ECamModeChangeInactive;
 iModeChangePhase = ECamModeChangePhaseIdle;
 callback         = EFalse;
 NotifyObservers( iModeChangeStatus,
 ECamCameraEventVideoInit,
 ECamCameraEventClassVideo );
 break;
 }
 // -------------------------------
 default:
 {
 // -------------------------------
 case ECamModeChangePhase0:
 {
 PRINT( _L("Camera <> Phase0: Release camera..") );
 TInt cameraIndex = iInfo.iCurrentCamera;
 ReleaseCurrentCamera();
 SwitchCameraL( cameraIndex );
 CompleteSwitchCameraL();
 callback = EFalse;
 break;
 case ECamModeChangePhase3:
 {
 PRINT( _L("Camera <> Phase3: Prepare image..") );
 TPckgBuf<TCamParamsImage> params;
 iSettingProvider.ProvideCameraParamL( ECameraParamImage, &params );
 // Query the supported resolutions for the selected format.
 TInt index = GetResolutionIndexL( params().iFormat, params().iSize );
 User::LeaveIfError( index );
 PRINT2( _L("Camera <> Image size: (%d, %d)"),
 params().iSize.iWidth,
 params().iSize.iHeight );
 iCamera->PrepareImageCaptureL( params().iFormat, index );
 iCamera->SetJpegQuality( params().iQualityFactor );
 SetFlags( iInfo.iState, ECamImageOn );
 callback  = EFalse;
 break;
 }
 PRINT( _L("Camera <> Phase4: Notifying..") );
 iModeChange      = ECamModeChangeInactive;
 iModeChangePhase = ECamModeChangePhaseIdle;
 callback         = EFalse;
 NotifyObservers( iModeChangeStatus,
 ECamCameraEventImageInit,
 ECamCameraEventClassImage );
 break;
 }
 // -------------------------------
 default:
 {
 /**
 * CCamCameraController::RemainingVideoRecordingTime()
 * Method to retrieve Remaining Recording time from CCaeEngine
 * which is used in AppController and AppUi during Video Rec Operation
 */
 TTimeIntervalMicroSeconds
 CCamCameraController::RemainingVideoRecordingTime()
 	{
 	if( iCaeEngine )
 	return iCaeEngine->RemainingVideoRecordingTime();
 else
 	}
 // ===========================================================================
 // Performance measurement related
 #ifdef CAMERAAPP_PERFORMANCE_CONTROLLER
 // ---------------------------------------------------------------------------
 // PerformanceLogger()
 //
 // Return the performance logger instance.
 // Used to record performance measurement data.
 // ---------------------------------------------------------------------------
 //
 const CCamPerformanceLogger*
 CCamCameraController::PerformanceLogger() const
 {
 return iPerformanceLogger;
 }
 #ifdef _DEBUG
 // ---------------------------------------------------------------------------
 // PrintCameraInfo
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::PrintCameraInfo() const
 {
 PRINT ( _L("Camera <> ==================================================") );
 PRINT ( _L("Camera <> Camera info:") );
 PRINT3( _L("Camera <> Camera hw version[%d.%d.%d]"),
 iCameraInfo.iHardwareVersion.iMajor,
 iCameraInfo.iHardwareVersion.iMinor,
 iCameraInfo.iHardwareVersion.iBuild );
 PRINT3( _L("Camera <> Camera sw version[%d.%d.%d]"),
 iCameraInfo.iSoftwareVersion.iMajor,
 iCameraInfo.iSoftwareVersion.iMinor,
 iCameraInfo.iSoftwareVersion.iBuild );
 PRINT1( _L("Camera <> TCameraInfo.iMinZoom             : %d"), iCameraInfo.iMinZoom );
 PRINT1( _L("Camera <> TCameraInfo.iMaxZoom             : %d"), iCameraInfo.iMaxZoom );
 PRINT1( _L("Camera <> TCameraInfo.iMaxDigitalZoom      : %d"), iCameraInfo.iMaxDigitalZoom );
 PRINT1( _L("Camera <> TCameraInfo.iMinZoomFactor       : %f"), iCameraInfo.iMinZoomFactor );
 PRINT1( _L("Camera <> TCameraInfo.iMaxZoomFactor       : %f"), iCameraInfo.iMaxZoomFactor );
 PRINT1( _L("Camera <> TCameraInfo.iMaxDigitalZoomFactor: %f"), iCameraInfo.iMaxDigitalZoomFactor );
 PRINT ( _L("Camera <> ==================================================") );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // CCamCameraController::SettingValueUpToDateL
 // ---------------------------------------------------------------------------
 //
 TBool
 CCamCameraController::SettingValueUpToDateL( const NCamCameraController::TCamCameraSettingId& aSettingId )
 {
 PRINT( _L("Camera => CCamCameraController::SettingValueUpToDate") );
 TBool upToDate = ETrue;
 switch( aSettingId )
 {
 case ECameraSettingFlash:
 case ECameraUserSceneSettingFlash:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingFlash") );
 // Supposed setting value from settings provider
 CCamera::TFlash flashSetting( CCamera::EFlashNone );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &flashSetting );
 // Real settings value from camera
 CCamera::TFlash flashValue( CCamera::EFlashNone );
 GetCameraSettingValueL( aSettingId, &flashValue );
 PRINT2( _L("Camera <> flashValue = %d, flashSetting = %d"), flashValue, flashSetting );
 upToDate = ( flashValue == flashSetting );
 break;
 }
 case ECameraSettingExposure:
 case ECameraUserSceneSettingExposure:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingExposure") );
 TPckgBuf<TCamSettingDataExposure> exposureSetting;
 iSettingProvider.ProvideCameraSettingL( aSettingId, &exposureSetting );
 TPckgBuf<TCamSettingDataExposure> exposureValue;
 GetCameraSettingValueL( aSettingId, &exposureValue );
 if ( exposureSetting().iExposureMode != exposureValue().iExposureMode ||
 exposureSetting().iExposureStep != exposureValue().iExposureStep )
 {
 upToDate = EFalse;
 }
 break;
 }
 case ECameraSettingLightSensitivity:
 case ECameraUserSceneSettingLightSensitivity:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingLightSensitivity") );
 RArray<TInt> ISOarray;
 CleanupClosePushL( ISOarray );
 #ifdef CAMERAAPP_CAPI_V2
 iAdvancedSettings->GetSupportedIsoRatesL( ISOarray );
 #endif
 TInt* isoSetting = 0;
 iSettingProvider.ProvideCameraSettingL( aSettingId, &isoSetting );
 CleanupStack::PopAndDestroy( &ISOarray );
 TInt* isoValue = 0;
 GetCameraSettingValueL( aSettingId, &isoValue );
 upToDate = ( isoSetting == isoValue );
 break;
 }
 case ECameraSettingWhiteBalance:
 case ECameraUserSceneSettingWhiteBalance:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingWhiteBalance") );
 TPckgBuf<TCamSettingDataWhiteBalance> wbSetting;
 iSettingProvider.ProvideCameraSettingL( aSettingId, &wbSetting );
 TPckgBuf<TCamSettingDataWhiteBalance> wbValue;
 GetCameraSettingValueL( aSettingId, &wbValue );
 upToDate = ( wbSetting().iWhiteBalanceMode == wbValue().iWhiteBalanceMode );
 break;
 }
 case ECameraSettingColourEffect:
 case ECameraUserSceneSettingColourEffect:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingColourEffect") );
 CIP::TEffect effectSetting( CIP::EEffectNone );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &effectSetting );
 CIP::TEffect effectValue( CIP::EEffectNone );
 // Can't leave here or other settings won't be restored
 TRAP_IGNORE( GetCameraSettingValueL( aSettingId, &effectValue ) );
 upToDate = ( effectSetting == effectValue );
 break;
 }
 case ECameraSettingBrightness:
 case ECameraUserSceneSettingBrightness:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingBrightness") );
 CCamera::TBrightness brightnessSetting;
 iSettingProvider.ProvideCameraSettingL( aSettingId, &brightnessSetting );
 CCamera::TBrightness brightnessValue;
 GetCameraSettingValueL( aSettingId, &brightnessValue );
 upToDate = ( brightnessSetting == brightnessValue );
 break;
 }
 case ECameraSettingContrast:
 case ECameraUserSceneSettingContrast:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingContrast") );
 CCamera::TContrast contrastSetting( CCamera::EContrastAuto );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &contrastSetting );
 CCamera::TContrast contrastValue( CCamera::EContrastAuto );
 GetCameraSettingValueL( aSettingId, &contrastValue );
 upToDate = ( contrastSetting == contrastValue );
 break;
 }
 case ECameraSettingSharpness:
 case ECameraUserSceneSettingSharpness:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingSharpness") );
 TInt sharpnessSetting( 0 );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &sharpnessSetting );
 TInt sharpnessValue( 0 );
 // Can't leave here or other settings won't be restored
 TRAP_IGNORE( GetCameraSettingValueL( aSettingId, &sharpnessValue ) );
 upToDate = ( sharpnessSetting == sharpnessValue );
 break;
 }
 case ECameraSettingDigitalZoom:
 {
 TInt zoomSetting( 0 );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &zoomSetting );
 TInt zoomValue( 0 );
 GetCameraSettingValueL( aSettingId, &zoomValue );
 upToDate = ( zoomSetting == zoomValue );
 break;
 }
 #ifdef CAMERAAPP_CAPI_V2
 case ECameraSettingStabilization:
 {
 PRINT( _L("Camera <> CCamCameraController::SettingValueUpToDate ECameraSettingStabilization") );
 TPckgBuf<TCamSettingDataStabilization> stabilizationSetting;
 iSettingProvider.ProvideCameraSettingL( aSettingId, &stabilizationSetting );
 TPckgBuf<TCamSettingDataStabilization> stabilizationValue;
 GetCameraSettingValueL( aSettingId, &stabilizationValue );
 if ( stabilizationSetting().iMode != stabilizationValue().iMode ||
 stabilizationSetting().iEffect != stabilizationValue().iEffect ||
 stabilizationSetting().iComplexity != stabilizationValue().iComplexity )
 {
 upToDate = EFalse;
 }
 break;
 }
 case ECameraSettingContAF:
 {
 TBool isContAFon( iAdvancedSettings->AutoFocusType() &
 CAS::EAutoFocusTypeContinuous );
 if( IsFlagOn( iInfo.iState, ECamVideoOn ) )
 {
 TBool contAF( ETrue );
 iSettingProvider.ProvideCameraSettingL( aSettingId, &contAF );
 if( contAF != isContAFon )
 {
 upToDate = EFalse;
 }
 }
 else
 {
 //Do nothing
 }
 break;
 }
 #endif
 default:
 {
 PRINT1( _L("CCamCameraController::SettingValueUpToDate - unknown setting id: %d"), aSettingId );
 }
 }
 PRINT1( _L("Camera <= CCamCameraController::SettingValueUpToDate returning %d"), upToDate );
 return upToDate;
 }
 PRINT( _L("Camera <> viewfinder active and window handle changed, restarting viewfinder...") );
 iCamera->StopViewFinder();
 iInfo.iVfState = ECamTriInactive;
 // restart viewfinder
 //TRAP_IGNORE( ProcessVfStartRequestL() );
 		iAppController.EnterViewfinderMode(iAppController.CurrentMode());
 }
 iViewfinderWindow = aWindow;
 PRINT( _L("Camera <= CCamCameraController::SetViewfinderWindowHandle") );
 // ---------------------------------------------------------------------------
 // CCamCameraController::SetVfWindowOrdinal
 // ---------------------------------------------------------------------------
 //
 TInt CCamCameraController::SetVfWindowOrdinal( TInt aOrdinalPosition )
 {
 TInt orgPos( KErrUnknown );
 CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
 if ( iViewfinderWindow )
 {
 TInt cbaPos(0);
 TInt toolbarPos(0);
 CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
 else if ( appUi )
 {
 // Find out other windows ordinal positions
 if ( cba )
 {
 cbaPos =  cba->DrawableWindow()->OrdinalPosition();
 }
 CAknToolbar* toolbar = appUi->CurrentFixedToolbar();
 if ( toolbar )
 {
 RDrawableWindow* toolbarwindow = toolbar->DrawableWindow();
 if ( toolbarwindow )
 {
 toolbarPos = toolbarwindow->OrdinalPosition();
 }
 }
 // Calculate new viewfinder position,
 // just under fixed toolbar and CBA buttons
 TInt newPos = Max( toolbarPos, cbaPos ) + 1;
 // Use new position if viefinder window is not visible already
 iViewfinderWindow->SetOrdinalPosition( Min( orgPos, newPos ) );
 // ---------------------------------------------------------------------------
 // CCamCameraController::DelayedCaeCallback
 // Static function called when the timer expires
 // ---------------------------------------------------------------------------
 //
 TInt
 CCamCameraController::DelayedCaeCallback( TAny* aController )
 {
 CCamCameraController* self = static_cast<CCamCameraController*>( aController );
 self->CallAppropriateCallback();
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // CCamCameraController::CallAppropriateCallback
 // Helper function to call the appropriate callback handler.
 // ---------------------------------------------------------------------------
 //
 void
 CCamCameraController::CallAppropriateCallback( const TCamCameraEventId aEventId,
 TInt              aStatus )
 {
 PRINT2( _L("Camera => CCamCameraController::CallAppropriateCallback, event:%d, status:%d"), aEventId, aStatus )
 switch ( iSimEventId )
 {
 case ECamCameraEventVideoInit:
 case ECamCameraEventVideoStart:  // fallthrough
 case ECamCameraEventVideoPause:  // fallthrough
 if( aEventId == ECamCameraEventNone )
 {
 PRINT( _L("Camera <> CCamCameraController::CallAppropriateCallback - calling handler after delay") )
 HandleVideoEvent( iSimEventId, iSimStatus );
 }
 else
 {
 PRINT( _L("Camera <> CCamCameraController::CallAppropriateCallback - calling handler without delay") )
 HandleVideoEvent( aEventId, aStatus );
 }
 break;
 default:
 break;
 }
 // In case of being called by timer, stop and destro the timer
 if( aEventId == ECamCameraEventNone && iCallbackTimer )
 {
 iCallbackTimer->Cancel();
 delete iCallbackTimer;
 iCallbackTimer = NULL;
 }
 PRINT( _L("Camera <= CCamCameraController::CallAppropriateCallback") )
 }
 #endif // CAMERAAPP_CAE_ERR_SIMULATION
 // ---------------------------------------------------------------------------
 // CCamCameraController::AsyncVideoStopModeSupported
 // ---------------------------------------------------------------------------
 //
 TBool
 CCamCameraController::AsyncVideoStopModeSupported()
 {
 PRINT1( _L("Camera <> CCamCameraController::AsyncVideoStopModeSupported = %d "), iAsyncVideoStopModeSupported );
 return( iAsyncVideoStopModeSupported );
 }
 // ---------------------------------------------------------------------------
 // IdleCallback <<static>>
 // ---------------------------------------------------------------------------
 //
 // static
 TInt CCamCameraController::IdleCallback( TAny* aSelf )
 {
 CCamCameraController* self( static_cast<CCamCameraController*>( aSelf ) );
 self->DoIveRecovery();
 // ---------------------------------------------------------------------------
 //
 void CCamCameraController::DoIveRecovery()
 {
 PRINT( _L("Camera => CCamCameraController::DoIveRecovery") )
 if( iAppController.IsAppUiAvailable()
 && !( iAppController.IsInShutdownMode() || iAppController.CheckExitStatus() ) )
 {
 CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
 __ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));
 		TVwsViewId activeView;
 }
 else
 {
 //There was an error when getting active view ID. Propably camera
 //application went to background. In that case just return because
 //camera resource should be released when going to background.
 return;
 }
 		__ASSERT_DEBUG(view, CamPanic(ECamPanicNullPointer));
 if ( appUi->StandbyStatus() && view->IsInStandbyMode() )
 {
 PRINT( _L("Camera <> CCamCameraController::DoIveRecovery - Standby mode active, try to exit") )
 TRAP_IGNORE( appUi->HandleControllerEventL(  ECamEventCameraChanged,
 KErrNone ) );
 }
 else
 {
 PRINT( _L("Camera <> CCamCameraController::DoIveRecovery - Start recovering from beginning") )
 iIveSequenceActive = EFalse;
 if( IsFlagOn( iInfo.iBusy, ECamBusySequence|ECamBusySetting ) )
 {
 if( iActive &&
 iActive->IsActive() )
 {
 iActive->Cancel();
 }
 iIveCancel = ETrue;
 EndSequence( KErrNone ); // Clears iIveRecoveryOngoing and iIveSequenceActive
 }
 NotifyObservers( KErrNone, ECamCameraEventIveRecover,
 ECamCameraEventClassBasicControl );
 }
 iIveRecoveryCount--;
 iIveRecoveryOngoing = ETrue;
 iIveCancel = EFalse;
 }
 PRINT1( _L("Camera <= CCamCameraController::DoIveRecovery iIveRecoveryCount%d"),iIveRecoveryCount )
 }
 // ---------------------------------------------------------------------------
 // CCamCameraController::IsWaitingIveResources
 // ---------------------------------------------------------------------------
 //
 TBool CCamCameraController::IsWaitingIveResources()
 {
 // ETrue if recovery is started, but not completed.
 // iIveRecoveryOngoing is set to false when last recovery command is executed
 return (iIdle && iIdle->IsActive()) ||
 iIveCancel || iIveRecoveryOngoing || iIveSequenceActive;
 }
 // ---------------------------------------------------------------------------
 // CCamCameraController::SetFaceTrackingL
 // ---------------------------------------------------------------------------
 //
 void CCamCameraController::SetFaceTrackingL()
 {
 if( iCustomInterfaceFaceTracking &&
 KPrimaryCameraIndex == iInfo.iCurrentCamera )
 {
 TBool ftOn( EFalse );
 iSettingProvider.ProvideCameraSettingL( ECameraSettingFacetracking, &ftOn );
 PRINT1( _L("Camera <> Set facetracking: %d"), ftOn )

branch	RCL_3
changeset 10	8c55c525d5d7
parent 9	792dfc98fb3b
child 11	d486e5e3cc9a