FCL/sf/app/camera: comparison camerauis/cameraapp/generic/src/CamAppController.cpp

equal deleted inserted replaced

--1:000000000000
+:1ddebce53859
+/*
+* Copyright (c) 2007-2009 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".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Class for managing intercommunication between Camera UI*
+*/
+// ===========================================================================
+// INCLUDE FILES
+#include <bldvariant.hrh> // for feature definitions
+#include <e32property.h>
+#include <apparc.h>
+#include <fbs.h>
+#include <eikenv.h>
+#include <hal.h>
+#include <hal_data.h>
+#include <pathinfo.h>
+#include <barsread.h>
+#include <AknUtils.h>
+#include <akntoolbar.h>
+#include <ProductVariant.hrh>
+#include <centralrepository.h>
+#include <ctsydomainpskeys.h>
+#include <ProfileEngineSDKCRKeys.h>
+#include <sysutildomaincrkeys.h>
+#include <ScreensaverInternalPSKeys.h>
+#include <musresourceproperties.h>
+#include <cameraplatpskeys.h>
+#include <bitmaptransforms.h>
+#include <sensrvorientationsensor.h>
+#include <sensrvchannel.h>
+#include <sensrvchannelfinder.h>
+#include <UsbWatcherInternalPSKeys.h>
+#include <usbpersonalityids.h>
+#include <cameraapp.rsg>
+#include <vgacamsettings.rsg>
+#include "CamSettingsInternal.hrh"
+#include "CamProductSpecificSettings.hrh"
+#include "CameraappPrivateCRKeys.h"
+#include "CamAppController.h"
+#include "CamUtility.h"
+#include "CamLogger.h"
+#include "CamSettings.hrh"
+#include "CamSettingsModel.h"
+#include "CamPanic.h"
+#include "CamBurstCaptureArray.h"
+#include "CamTimer.h"
+#include "CamImageSaveActive.h"
+#include "CamAppUi.h"
+#include "CamObserverHandler.h"
+#include "CamSelfTimer.h"
+#include "camflashstatus.h"
+#include "CamPerformance.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "CamAppControllerTraces.h"
+#endif
+#include "CamVideoQualityLevel.h"
+#include "CamCallStateAo.h"
+#include "CamPropertyWatcher.h"
+#include <avkondomainpskeys.h>
+#ifndef __WINSCW__
+#include "rlocationtrail.h"
+#include "locationtrailpskeys.h"
+#endif
+//#include "camconstantsettingprovider.h"
+#include "camsettingprovider.h"
+#include "camsettingconversion.h"
+#include "camcamerarequests.h"
+#include "camcameraevents.h"
+#include "camcameracontrollertypes.h"
+#include "camcameracontroller.h"
+#include "cambuffershare.h"
+#include "cambuffersharecleanup.h"
+#include "camaudioplayercontroller.h"
+#include "camuidconstants.h"
+#include "camconfiguration.h"
+#include "CamPreCaptureViewBase.h"
+#include <cfclient.h>
+#include <cfcontextobject.h>
+#include <cfcontextquery.h>
+#include "camvideotime.h"
+#include "CamGSInterface.h"
+#include "CameraUiConfigManager.h"
+#include <bitmaptransforms.h>
+#ifdef _DEBUG
+#ifdef _AO_TRACKING
+struct CFakeActiveScheduler : public CActiveScheduler {
+virtual TInt Extension_( TUint, TAny *&, TAny* ) { return 0; }
+};
+#endif // _AO_TRACKING
+#endif // _DEBUG
+// ===========================================================================
+// Local constants
+// Sequence mode related constants that define the amount of pictures taken
+// with sequence mode.
+const TInt KShortBurstCount  = 18;   // number of images captured during burst
+const TInt KMinBurstCount    = 2;    // minimum of images captured
+const TInt KBurstEstimate    = 10;   // Correction of underestimated file size
+const TUint32 KCamLatestFilePath      = 0x00000001;
+// temporary constants until image naming is implemented
+_LIT( KImageExtension, ".jpg" );
+_LIT( KVideo3GPExtension, ".3gp" );
+#ifndef __WINS__
+_LIT( KVideoMP4Extension, ".mp4" );
+#endif
+const TInt KMaxExtension = 4;
+//const TInt64 KBurstInterval = 0;
+const TInt KIdleTimeout     = 1000000 * 60; // 60 seconds
+const TInt KDeepSleepTimeout = KIdleTimeout*2; // Measuring time is two minutes
+const TInt KVideoArrayUsers = 1;
+const TInt KImageArrayUsers = 2;
+const TInt KVideoNameRetryCount = 1;    // Maximum number of video naming retries
+// UID for central repository file
+const TInt KCRCamShutterSound = 0x7; // key for shutter sound
+const TInt KMicroSecsInMilliSec = 1000;
+const TInt KSecondInMicSec = 1000000;
+#if defined(RD_MDS_2_5) && !defined(__WINSCW__)
+const TInt KLocTrailCloseRetryTime = 5 * KSecondInMicSec;
+#endif // defined(RD_MDS_2_5) && !defined(__WINSCW__)
+// Estimated time needed to complete autofocus
+const TInt KFocusingDurationSeconds = 2;
+const TInt KCCorFocused = 0x00000002;
+const TInt KCamMaxDateLen = 8;
+static const TInt KTimelapseArrayGranularity = 6;
+// Backlight / Inactivity timer related
+//   Callback interval is set to 4s.
+//   Smallest value that the user can select from Phone Settings is 5s.
+static const TInt KBacklighTimerPriority = CActive::EPriorityHigh;
+static const TInt KBacklighTimerInterval = 4*1000*1000;
+// Camera Controller events interest.
+//   Want to receive all events.
+//   Vf frames needed for correct zoom handling (should be left out otherwise).
+static const TUint KCamEventInterest = (  ECamCameraEventClassAll );
+static const TInt KLensCoverDelay = 500*1000;
+_LIT( KCamContextSource, "Application" );
+_LIT( KCamContextType, "Camera.Zoom" );
+_LIT( KCamContextValueEnable, "Enabled" );
+_LIT( KCamContextValueDisable, "Disabled" );
+_LIT_SECURITY_POLICY_PASS( KCamContextSecurity );
+static const TInt KCriticalMemoryLevel = 5*1000*1000;
+// ===========================================================================
+// Local namespace
+namespace NCamAppController
+{
+// -------------------------------------------------------
+// Request sequences
+//  static const TCamCameraRequestId KCamSequencePowerOffOn[] =
+//    {
+//    ECamRequestPowerOff,
+//    ECamRequestPowerOn
+//    };
+// -------------------------------------------------------
+// Local methods
+inline TInt ResetBitmap( CFbsBitmap*& aBitmap )
+{
+if( aBitmap )
+{
+aBitmap->Reset();
+return KErrNone;
+}
+else
+{
+TRAPD( create, aBitmap = new (ELeave) CFbsBitmap() );
+return create;
+}
+};
+inline void ClearSequenceBusyFlag( TAny* aBusyFlags )
+{
+TUint* flags = static_cast<TUint*>( aBusyFlags );
+if( flags )
+{
+*flags &= ~EBusySequence;
+}
+};
+inline void ClearRequestBusyFlag( TAny* aBusyFlags )
+{
+TUint* flags = static_cast<TUint*>( aBusyFlags );
+if( flags )
+{
+*flags &= ~EBusyRequest;
+}
+};
+}
+#include "camflagutility.inl"
+#include "campointerutility.inl"
+using namespace NCamAppController;
+using namespace NCamCameraController;
+// ===========================================================================
+// ===========================================================================
+// Member functions
+// ---------------------------------------------------------------------------
+// CCamAppController::NewL
+// Two-phased constructor.
+// ---------------------------------------------------------------------------
+//
+CCamAppController* CCamAppController::NewL()
+{
+CCamAppController* self = new( ELeave ) CCamAppController();
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop( self );
+return self;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CompleteConstructionL
+// The camera engine cannot be instantiated until the application orientation has
+// been set by the CCamAppUi. This does not exist when the CCamAppController is
+// constructed. CompleteConstructionL must be called in CCamAppUi::ConstructL()
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CompleteConstructionL()
+{
+PRINT( _L("Camera => CCamAppController::CompleteConstructionL" ))
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// Memory critical levels reading moved to the point when
+// those values are actually needed for the first time.
+TInt index = 0;
+iInfo.iActiveCamera = ECamActiveCameraPrimary;
+PRINT1( _L("Camera <> Cameras available: %d"), CamerasAvailable() )
+PRINT( _L("Camera <> Store primary camera settings"))
+iSettingsModel->StorePrimaryCameraSettingsL();
+PRINT1( _L("Camera <> CCamAppController::CompleteConstructionL iSlideState initial value = %d" ), iSlideState)
+if ( iConfigManager->IsLensCoverSupported() )
+{
+// Request notification of slide state changes
+iSlideStateWatcher->Subscribe();
+// Read the current slider status - use the front camera (if there is one) as default if
+// there are any errors.
+TInt slideErr = iSlideStateWatcher->Get( iSlideState );
+PRINT1( _L("Camera <> CCamAppController::CompleteConstructionL setting iSlideState to %d" ), iSlideState)
+TInt requiredOrientation;
+if ( ( appUi->CamOrientation() == ECamOrientationCamcorderLeft && iSlideState == CameraPlatPSKeys::EClosed ) ||
+( appUi->CamOrientation() == ECamOrientationCamcorder && iSlideState == CameraPlatPSKeys::EClosed ) )
+{
+if ( appUi->IsQwerty2ndCamera() )
+{
+PRINT( _L("Camera <> Do not exit. Reload landscape 2nd camera settings") )
+index = 1;
+iInfo.iActiveCamera = ECamActiveCameraSecondary;
+CCamAppUi* appUi = static_cast<CCamAppUi*>(
+CEikonEnv::Static()->AppUi() );
+// We may have primary camera settings loaded
+LoadStaticSettingsL( appUi->IsEmbedded() );
+CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation,
+requiredOrientation );
+}
+else
+{
+PRINT( _L("Camera <> Lens cover has been closed during camera construction. Exit camera.") )
+appUi->HandleCommandL( EEikCmdExit);
+}
+}
+else
+{
+// if the slide is closed or there is an error, then use the front camera
+// check that there is more than 1 camera and that the current orientation is correct
+if ( ( iSlideState == CameraPlatPSKeys::EClosed
+|| slideErr    != KErrNone )
+&& CamerasAvailable() > 1 )
+{
+PRINT( _L("Camera <> CCamAppController::CompleteConstructionL slider is not open" ))
+index = 1;
+iInfo.iActiveCamera = ECamActiveCameraSecondary;
+CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, requiredOrientation );
+}
+else // slide is open or using primary camera as default
+{
+PRINT( _L("Camera <> CCamAppController::CompleteConstructionL slider is open- primary camera in use" ))
+index = 0;
+iInfo.iActiveCamera = ECamActiveCameraPrimary;
+//when active camera is primary camera,orientation must be landscape,
+//so need to fix orientation
+if ( ECamOrientationPortrait == appUi->CamOrientation() )
+{
+TInt primaryOrientation;
+CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation,
+primaryOrientation );
+appUi->SetOrientationL( ( CAknAppUiBase::TAppUiOrientation ) primaryOrientation );
+appUi->SetCamOrientationToLandscape();
+}
+}
+}
+}
+ConstructCameraControllerL( index );
+// Send startup sequence ?
+/**
+* Removed all custom interfaces requested from engine
+*/
+iAccSensorListening = EFalse;
+iCallStateAo = CCamCallStateAo::NewL( this );
+// Use backlight timer instead of every Nth vf frame event
+// to reset inactivity timer. This is to avoid adding load
+// when higher VF frame rates are used (and overall load is
+// already higher).
+iBacklightTimer = CPeriodic::NewL( KBacklighTimerPriority );
+#ifdef _DEBUG
+#ifdef _AO_TRACKING
+TAny *iAoBacklightTimer = (TAny *)iBacklightTimer;
+PRINT2( _L("Camera <> CCamAppController: BacklightTimer=%x, %d"),iBacklightTimer, iAoBacklightTimer );
+CActiveScheduler *pAS = CActiveScheduler::Current();
+CFakeActiveScheduler *pFAS = static_cast<CFakeActiveScheduler*>(pAS);
+pFAS->Extension_( 0, iAoBacklightTimer, (TAny *)("iBacklightTimer") );
+#endif // _AO_TRACKING
+#endif // _DEBUG
+#ifdef _DEBUG
+#ifdef _AO_TRACKING
+TAny *iAoDeepSleepTimer = (TAny *)iDeepSleepTimer;
+PRINT2( _L("Camera <> CCamAppController: DeepSleepTimer=%x, %d"),iDeepSleepTimer, iAoDeepSleepTimer );
+CActiveScheduler *pAS2 = CActiveScheduler::Current();
+CFakeActiveScheduler *pFAS2 = static_cast<CFakeActiveScheduler*>(pAS2);
+pFAS2->Extension_( 0, iAoDeepSleepTimer, (TAny *)("iDeepSleepTimer") );
+#endif // _AO_TRACKING
+#endif // _DEBUG
+if ( UiConfigManagerPtr()->IsXenonFlashSupported() )
+{
+PRINT( _L("Camera <> CCamAppController: Create flash status observer..") );
+iFlashStatus = CCamFlashStatus::NewL( *this );
+}
+PRINT( _L("Camera <= CCamAppController::CompleteConstructionL" ))
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::GetCriticalMemoryLevelL( const TCamMediaStorage& aStorage )
+{
+PRINT( _L("Camera => CCamAppController::GetCriticalMemoryLevelL" ) )
+// If this is the first call here, get the critical levels from
+// Central repository. Later the cached values will be used.
+if( KErrNotFound == iRamDiskCriticalLevel
+|| KErrNotFound == iDiskCriticalLevel   )
+{
+CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );
+TInt err;
+err = repository->Get( KDiskCriticalThreshold , iDiskCriticalLevel );
+if ( KErrNone != err )
+{
+CamPanic( ECamPanicDefaultNotFoundInIniFile );
+}
+err = repository->Get( KRamDiskCriticalLevel , iRamDiskCriticalLevel );
+if ( KErrNone != err )
+{
+CamPanic( ECamPanicDefaultNotFoundInIniFile );
+}
+CleanupStack::PopAndDestroy( repository );
+}
+TInt level = ( aStorage == ECamMediaStoragePhone )
+? iRamDiskCriticalLevel
+: iDiskCriticalLevel;
+PRINT1( _L("Camera <= CCamAppController::GetCriticalMemoryLevelL, level:%d" ), level )
+return level;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::~CCamAppController
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CCamAppController::~CCamAppController()
+{
+PRINT( _L("Camera => ~CCamAppController") );
+// As a precaution, make sure the screen saver is never left in a disabled state
+EnableScreenSaver( ETrue );
+RProperty::Set( KPSUidCamcorderNotifier, KCCorFocused, 0 );
+if ( iFlashStatus )
+{
+delete iFlashStatus;
+}
+delete iSoundPlayer;
+PRINT( _L("Camera <> close observers array..") );
+__ASSERT_DEBUG( iControllerObservers.Count() == 0, CamPanic( ECamPanicResourceLeak ) );
+iControllerObservers.Close();
+delete iCallStateAo;
+delete iBurstTimer;
+// Using timer also on bitmap mode.
+if( iBacklightTimer )
+{
+iBacklightTimer->Cancel();
+delete iBacklightTimer;
+}
+if( iConfigManager && iConfigManager->IsOrientationSensorSupported() &&
+		iAccSensorListening )
+{
+iAccSensorChannel->StopDataListening();
+iAccSensorChannel->CloseChannel();
+}
+delete iAccSensorChannel;
+if ( iSlideStateWatcher )
+{
+iSlideStateWatcher->Cancel();
+delete iSlideStateWatcher;
+}
+if ( iSliderCallBack )
+{
+iSliderCallBack->Cancel();
+delete iSliderCallBack;
+iSliderCallBack = NULL;
+}
+if ( iKeyLockStatusWatcher && iConfigManager && iConfigManager->IsKeyLockWatcherSupported() )
+{
+iKeyLockStatusWatcher->Cancel();
+delete iKeyLockStatusWatcher;
+}
+if ( iConfigManager  && iConfigManager->IsPublishZoomStateSupported() )
+{
+TRAP_IGNORE ( PublishZoomStateL( EFalse ) );
+delete iContextFwClient;
+}
+if ( iConfigManager  && iConfigManager->IsLocationSupported() )
+{
+if( iLocationTrailTimer )
+{
+iLocationTrailTimer->Cancel();
+delete iLocationTrailTimer;
+iLocationTrailTimer = NULL;
+}
+}
+if ( iConfigManager  && iConfigManager->IsLocationSupported() )
+{
+// stop trail and close session
+StopLocationTrail( ETrue );
+}
+if ( iImageSaveActive )
+{
+iImageSaveActive->ForceCancel();
+delete iImageSaveActive;
+}
+PRINT( _L("Camera <> delete settingsmodel..") );
+delete iSettingsModel;  // Must be before iEngine deleted
+iSettingsPreviewHandler = NULL; // Currently the Settings Model object.
+iPreviewRollbacks.Close();
+delete iCaptureArray;
+delete iRotationArray;
+if ( iSequenceFilenameArray )
+{
+iSequenceFilenameArray->Reset();
+delete iSequenceFilenameArray;
+}
+if( iDeepSleepTimer )
+{
+iDeepSleepTimer->Cancel();
+delete iDeepSleepTimer;
+}
+if( iIdleTimer )
+{
+iIdleTimer->Cancel();
+delete iIdleTimer;
+}
+if ( iTimeLapseTimer )
+{
+iTimeLapseTimer->Cancel();
+delete iTimeLapseTimer;
+}
+if( iCaptureToneDelayTimer )
+{
+iCaptureToneDelayTimer->Cancel();
+delete iCaptureToneDelayTimer;
+}
+delete iCaptureCompletionObserverHandler;
+delete iSnapShotCopy;
+iJpegDataSizes.Close();
+iSequencePostProcessDataSizes.Close();
+// Close the arrays
+iPendingObserversArray.Close();
+iCameraEventInterested.Close();
+// Controller handles releasing CCamera if needed.
+PRINT( _L("Camera <> delete camera controller..") );
+delete iCameraController;
+PRINT( _L("Camera <> delete setting provider..") );
+delete iSettingProvider;
+PRINT( _L("Camera <= ~CCamAppController") );
+PRINT( _L("Camera <> delete Configuration Manager..") );
+delete iConfiguration;
+iConfiguration = NULL;
+RProperty::Delete( KPSUidCamcorderNotifier, KCCorFocused );
+if( iPlugin )
+{
+// Destroy Ecom plugin
+iPlugin->DestroyPlugin();
+}
+iPlugin = NULL;
+delete iDriveChangeNotifier;
+iFs.Close();
+if( iRotatorAo )
+{
+delete iRotatorAo;
+}
+PRINT( _L("Camera <= ~CCamAppController") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SavedCurrentImage
+// Returns whether the last requested captured image has been saved or not.
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::SavedCurrentImage() const
+{
+PRINT( _L("Camera => CCamAppController::SavedCurrentImage") );
+TBool saved( ETrue );
+// If we are waiting for a save request then image has not been saved.
+if( iImageSaveRequestPending )
+{
+PRINT( _L("Camera <> CCamAppController::SavedCurrentImage: iImageSaveRequestPending") )
+saved = EFalse;
+}
+else if( CurrentFullFileName() == KNullDesC )
+{
+saved = EFalse;
+PRINT( _L("Camera <> CCamAppController::SavedCurrentImage: filename not yet reserved") )
+}
+else if( !iCaptureArray->AlreadySavedFile( CurrentFullFileName() ) ||
+iCaptureArray->CurrentlySavingFile( CurrentFullFileName() ) )
+{
+PRINT( _L("Camera <> CCamAppController::SavedCurrentImage: capture array not saved file or currently saving file") )
+saved = EFalse;
+}
+else if ( iInfo.iOperation == ECamCapturing || iInfo.iOperation == ECamCompleting )
+{
+	PRINT(_L("Camera CCamAppController::SavedCurrentImage returning false, capturing/completing") )
+	saved = EFalse;
+}
+else
+{
+// empty
+}
+PRINT1( _L("Camera <= CCamAppController::SavedCurrentImage, return %d"), saved );
+return saved;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RenameCurrentFileL
+// Rename image/video.
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::RenameCurrentFileL( const TDesC&          aNewName,
+const TCamCameraMode& /*aMode*/ )
+{
+TBool status = EFalse;
+// If file to rename has already been saved then remove from album,
+// rename the file and add the renamed file to the album.
+if ( BurstCaptureArray()->AlreadySavedFile( CurrentFullFileName() ) )
+{
+// Rename the file.
+TFileName filePath = CurrentFullFileName();
+CamUtility::RenameStillImageL( filePath, aNewName, filePath );
+// Update capture array with new name and path.
+BurstCaptureArray()->SetNameL( filePath, aNewName, iCurrentImageIndex );
+status = ETrue;
+}
+// Otherwise, if the file is not currently being saved, modify the names
+// in the capture array before it is saved.
+else if ( !BurstCaptureArray()->CurrentlySavingFile( CurrentFullFileName() ) )
+{
+// Update capture array with new name and path.
+// ...determine new path.
+TParsePtrC parse( CurrentFullFileName() );
+TFileName fullNewPath;
+fullNewPath = parse.DriveAndPath();
+fullNewPath.Append( aNewName );
+fullNewPath.Append( parse.Ext() );
+BurstCaptureArray()->SetNameL( fullNewPath, aNewName, iCurrentImageIndex );
+status = ETrue;
+}
+// Otherwise, the file is in the process of being saved, and
+// so that renaming must wait until completed.
+else
+{
+// Leave status to EFalse
+}
+return status;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::AddControllerObserverL
+// Add a controller observer.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::AddControllerObserverL( const MCamControllerObserver* aObserver )
+{
+if( aObserver &&
+KErrNotFound == iControllerObservers.Find( aObserver ) )
+{
+User::LeaveIfError( iControllerObservers.Append( aObserver ) );
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RemoveControllerObserver
+// Remove a controller observer.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::RemoveControllerObserver( const MCamControllerObserver* aObserver )
+{
+// Errors ignored
+if( aObserver )
+{
+TInt index = iControllerObservers.Find( aObserver );
+if( KErrNotFound != index )
+{
+iControllerObservers.Remove( index );
+}
+}
+}
+// ---------------------------------------------------------------------------
+// AddCameraObserverL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::AddCameraObserverL( const MCamCameraObserver* aObserver,
+const TUint&              aEventInterest )
+{
+PRINT1( _L("Camera => CCamAppController::AddCameraObserverL aObserver=%d"), aObserver );
+// First check that observer is not in array already
+if( KErrNotFound == iPendingObserversArray.Find( aObserver ) )
+{
+PRINT(_L("Camera <> CCamAppController::AddCameraObserverL add Observer") );
+iPendingObserversArray.AppendL( aObserver );
+iCameraEventInterested.AppendL( aEventInterest );
+}
+if( iCameraController )
+{
+PRINT(_L("Camera <> CCamAppController::AddCameraObserverL camera controller available") );
+while ( iPendingObserversArray.Count() > 0 &&
+iCameraEventInterested.Count() > 0 )
+{
+const MCamCameraObserver* camEventObserver = iPendingObserversArray[0];
+TUint eventInterest = iCameraEventInterested[0];
+iCameraController->AttachObserverL( camEventObserver, eventInterest );
+iPendingObserversArray.Remove( 0 );
+iCameraEventInterested.Remove( 0 );
+}
+}
+PRINT(_L("Camera <= CCamAppController::AddCameraObserverL") );
+}
+// ---------------------------------------------------------------------------
+// RemoveCameraObserver
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::RemoveCameraObserver( const MCamCameraObserver* aObserver )
+{
+if( iCameraController )
+iCameraController->DetachObserver( aObserver );
+}
+// ---------------------------------------------------------------------------
+// AddSettingsObserverL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::AddSettingsObserverL( const MCamSettingsModelObserver* aObserver )
+{
+if( iSettingsModel )
+iSettingsModel->AttachObserverL( aObserver );
+else
+User::Leave( KErrNotReady );
+}
+// ---------------------------------------------------------------------------
+// RemoveCameraObserver
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::RemoveSettingsObserver( const MCamSettingsModelObserver* aObserver )
+{
+if( iSettingsModel )
+iSettingsModel->DetachObserver( aObserver );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::ConstructCameraControllerL( TInt aCameraIndex )
+{
+OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMAPPCONTROLLER_CONSTRUCTCAMERACONTROLLERL, "e_CCamAppController_ConstructCameraControllerL 1" );
+PRINT( _L("Camera => CCamAppController::ConstructCameraControllerL") )
+PERF_EVENT_START_L2( EPerfEventCAEConstruction );
+if( !iCameraController )
+{
+iCameraController = CCamCameraController::NewL( *iSettingProvider, *this,
+aCameraIndex );
+//If uiorientationoverride feature is not supported, the camera switch has
+// to be finished here
+if( !( iConfigManager && iConfigManager->IsUIOrientationOverrideSupported() ) )
+{
+iCameraController->CompleteSwitchCameraL();
+}
+}
+// Attach as Camera Controller observer to get events
+PRINT1( _L("Camera <> Attaching as camera observer with interest:%032b"), KCamEventInterest );
+iCameraController->AttachObserverL( this, KCamEventInterest );
+PERF_EVENT_END_L2( EPerfEventCAEConstruction );
+PRINT( _L("Camera <= CCamAppController::ConstructCameraControllerL") )
+OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMAPPCONTROLLER_CONSTRUCTCAMERACONTROLLERL, "e_CCamAppController_ConstructCameraControllerL 0" );
+}
+// #################################################################################################
+// ---------------------------------------------------------------------------
+// Returns the current camera controller state
+// (Bitfield of type TCamCameraStateFlags )
+// ---------------------------------------------------------------------------
+//
+TUint
+CCamAppController::CameraControllerState() const
+{
+TUint state( ECamIdle );
+if( iCameraController )
+{
+state = iCameraController->State();
+}
+PRINT1( _L("Camera =><= CCamAppController::CameraControllerState(): %032b"), state );
+return state;
+}
+// ---------------------------------------------------------------------------
+// Returns the current camera state
+// (TCamCameraState)
+// ---------------------------------------------------------------------------
+//
+TCamCameraState
+CCamAppController::CameraState() const
+{
+TCamCameraState state( ECamCameraIdle );
+TUint controllerState = CameraControllerState();
+// Convert controller state to TCamCameraState
+// Use the state represented by the "most significant"
+// bit in the bitfield. Ignore VF state.
+if( IsFlagOn( controllerState, ECamImageOn ) )
+{
+state = ECamCameraPreparedImage;
+}
+else if( IsFlagOn( controllerState, ECamVideoOn ) )
+{
+state = ECamCameraPreparedVideo;
+}
+else if( IsFlagOn( controllerState, ECamPowerOn ) )
+{
+state = ECamCameraPowerOn;
+}
+else if( IsFlagOn( controllerState, ECamReserved ) )
+{
+state = ECamCameraReserved;
+}
+PRINT1( _L("Camera =><= CCamAppController::CameraState(): %d"), state );
+return state;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamCameraMode
+CCamAppController::CurrentMode() const
+{
+return iInfo.iMode;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamCameraMode
+CCamAppController::TargetMode() const
+{
+return iInfo.iTargetMode;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+// CCamAppController::CurrentCaptureModeSetup()
+TCamImageCaptureMode
+CCamAppController::CurrentImageModeSetup() const
+{
+TCamImageCaptureMode captureMode = ECamImageCaptureSingle;
+if( IsAppUiAvailable() )
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi->IsBurstEnabled() )
+{
+captureMode = appUi->CurrentBurstMode();
+}
+}
+return captureMode;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamCaptureOperation
+CCamAppController::CurrentOperation() const
+{
+return iInfo.iOperation;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamCaptureOperation
+CCamAppController::CurrentImageOperation() const
+{
+if( ECamControllerImage == iInfo.iMode )
+return iInfo.iOperation;
+else
+return ECamNoOperation;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamCaptureOperation
+CCamAppController::CurrentVideoOperation() const
+{
+if( ECamControllerVideo == iInfo.iMode )
+return iInfo.iOperation;
+else
+return ECamNoOperation;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamImageCaptureMode  CCamAppController::CurrentImageMode() const
+{
+return iInfo.iImageMode;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TCamCameraTriState CCamAppController::ViewfinderTargetState() const
+{
+return iInfo.iTargetVfState;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetMode( const TCamCameraMode& aNewMode )
+{
+PRINT3( _L("Camera => CCamAppController::SetMode old[%s] new[%s] target[%s]"),
+KCamModeNames[iInfo.iMode],
+KCamModeNames[aNewMode],
+KCamModeNames[iInfo.iTargetMode] );
+if( aNewMode != iInfo.iMode )
+{
+// In shutdown mode will not accept leaving ECamControllerShutdown state.
+TBool newModeNotAccepted = ( IsInShutdownMode()
+&& ECamControllerShutdown == iInfo.iMode
+&& ECamControllerShutdown != aNewMode );
+if( !newModeNotAccepted )
+{
+iInfo.iMode = aNewMode;
+NotifyControllerObservers( ECamEventEngineStateChanged );
+}
+else
+{
+PRINT( _L("Camera <> this mode change not acceptable in shutdown mode!") );
+}
+}
+PRINT( _L("Camera <= CCamAppController::SetMode") );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetTargetMode( const TCamCameraMode& aNewMode )
+{
+PRINT2( _L("Camera =><= CCamAppController::SetTargetMode [%s] -> [%s]"),
+KCamModeNames[iInfo.iTargetMode],
+KCamModeNames[aNewMode         ] );
+iInfo.iTargetMode = aNewMode;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetImageMode( const TCamImageCaptureMode& aNewMode )
+{
+PRINT2( _L("Camera =><= CCamAppController::SetImageMode [%s] -> [%s]"),
+KCamImageModeNames[iInfo.iImageMode],
+KCamImageModeNames[aNewMode        ] );
+iInfo.iImageMode = aNewMode;
+// Notify ??
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetTargetImageMode( const TCamImageCaptureMode& aNewMode )
+{
+PRINT2( _L("Camera =><= CCamAppController::SetTargetImageMode [%s] -> [%s]"),
+KCamImageModeNames[iInfo.iTargetImageMode],
+KCamImageModeNames[aNewMode              ] );
+iInfo.iTargetImageMode = aNewMode;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetOperation( TCamCaptureOperation aNewOperation,
+TInt                 aError /*= KErrNone*/ )
+{
+PRINT2( _L("Camera => CCamAppController::SetOperation: [%s] -> [%s]"),
+KCamCaptureOperationNames[iInfo.iOperation],
+KCamCaptureOperationNames[aNewOperation   ] );
+PERF_OPERATION_STATE_CHANGE( aNewOperation );
+if( iInfo.iOperation != aNewOperation
+|| aError           != KErrNone )
+{
+iInfo.iOperation = aNewOperation;
+NotifyControllerObservers( ECamEventOperationStateChanged, aError );
+}
+PRINT( _L("Camera <= CCamAppController::SetOperation") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ImagesRemaining
+// Return the number of images that can still be saved
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,
+TBool            aBurstActive )
+{
+TCamPhotoSizeId size = static_cast<TCamPhotoSizeId>
+( iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoSize ) );
+return ImagesRemaining( aStorage, aBurstActive, size );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ImagesRemaining
+// Return the number of images that can still be saved
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,
+TBool            aBurstActive,
+TInt             aQualityIndex )
+{
+TCamPhotoSizeId size = static_cast<TCamPhotoSizeId>
+( iSettingsModel->PhotoResolution( aQualityIndex ) );
+return ImagesRemaining( aStorage, aBurstActive, size );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ImagesRemaining
+// Return the number of images that can still be saved
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,
+TBool            aBurstActive,
+TCamPhotoSizeId  aSize        )
+{
+PRINT( _L("Camera => CCamAppController::ImagesRemaining" ))
+if ( ECamMediaStorageCurrent == aStorage )
+{
+TCamMediaStorage store_unfiltered = static_cast<TCamMediaStorage>
+( IntegerSettingValueUnfiltered( ECamSettingItemPhotoMediaStorage ) );
+// check to see if the MMC has been removed and we are waiting on a storage switch note
+// before we start returning the values for phone memory
+if( ECamMediaStorageCard == store_unfiltered
+&& static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() )->IsMMCRemovedNotePending()
+)
+{
+PRINT( _L("Camera <= CCamAppController::ImagesRemaining mmc removed - returning 0" ))
+return 0;// UI Behaves as if MMC is still memory in use, thus we return zero images remaining as MMC is removed
+}
+// use current storage location
+aStorage = static_cast<TCamMediaStorage>
+( IntegerSettingValue( ECamSettingItemPhotoMediaStorage ) );
+}
+else
+{
+// use specified location
+}
+TInt remaining     = 0;
+TInt criticalLevel = 0;
+PRINT( _L("Camera <> Get critical memory level.." ))
+TRAPD( err, criticalLevel = GetCriticalMemoryLevelL( aStorage ) );
+if( !err )
+remaining = iConfiguration->ImagesRemaining( aStorage, aSize, criticalLevel, aBurstActive  );
+// There is a factor in cenrep that defined a correction factor in percent.
+// This feature makes possible to define separate file size estimates in
+// burst capture mode.  100 = 100%, 50 = half of single capture size etc.
+if ( aBurstActive )
+{
+TInt corrFactor = iConfigManager->BurstFileSizeEstimateFactor();
+PRINT1( _L("Camera <> CCamAppController::ImagesRemaining, factor: %d"), corrFactor )
+remaining = TInt( remaining * corrFactor / 100 );
+}
+PRINT1( _L("Camera <= CCamAppController::ImagesRemaining, return:%d"), remaining )
+return remaining;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RecordTimeElapsed
+// Return the length of video that has been recorded
+// ---------------------------------------------------------------------------
+//
+TTimeIntervalMicroSeconds CCamAppController::RecordTimeElapsed() const
+{
+return iVideoTimeElapsed;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RecordTimeElapsed
+// Return the length of video that has been recorded
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::RecordTimeElapsed(TTimeIntervalMicroSeconds aElapsed )
+{
+iVideoTimeElapsed=aElapsed;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RecordTimeRemaining
+// Return the length of video that can still be saved
+// ---------------------------------------------------------------------------
+//
+TTimeIntervalMicroSeconds
+CCamAppController::RecordTimeRemaining()
+{
+PRINT( _L("Camera => CCamAppController::RecordTimeRemaining" ));
+TTimeIntervalMicroSeconds remain( 0 );
+// All the time we get this information from the CaeEngine which is thru camera controller.
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( appUi->SettingsLaunchedFromCamera() || iDismountPending )
+{
+// In case settings plugin is being run or mmc dismount is pending
+// due to usb activation, we calculate the remaining time here,
+// instead of repreparing the engine and getting it from there
+TRAPD( err, iVideoTimeRemaining = CalculateVideoTimeRemainingL() );
+if( KErrNone != err )
+{
+iVideoTimeRemaining = 0;
+}
+}
+else
+{
+if( iInfo.iOperation == ECamCapturing    ||
+iInfo.iOperation == ECamPausing      ||
+iInfo.iOperation == ECamPaused       ||
+iInfo.iOperation == ECamResuming     ||
+iInfo.iOperation == ECamCompleting )
+{
+iVideoTimeRemaining = iCameraController->RemainingVideoRecordingTime();
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController::RecordTimeRemaining - video mode not yet initialized" ));
+TRAPD( err, iVideoTimeRemaining = CalculateVideoTimeRemainingL() );
+if( KErrNone != err )
+{
+iVideoTimeRemaining = 0;
+}
+}
+}
+if ( ECamControllerVideo == CurrentMode() &&
+	    ECamMediaStorageCard == IntegerSettingValue( ECamSettingItemVideoMediaStorage ) &&
+	    appUi->IsMemoryFullOrUnavailable( ECamMediaStorageCard ) )
+{
+iVideoTimeRemaining =  0;
+}
+// if the storage location is MMC but the MMC is not accessible then
+// return 0 time remaining
+if ( appUi->IsMMCRemovedNotePending() )
+{
+// Return remaining time of zero, it will be reset when
+// a card is reinserted or storage location is changed
+PRINT( _L("Camera <> MMC note pending, return 0") );
+}
+else
+{
+// If the time we have is greater than the maximum allowed, return the
+// maximum
+TTimeIntervalMicroSeconds maxRecordingLength( static_cast<TInt64>(KMaxRecordingLength) );
+if ( iVideoTimeRemaining > maxRecordingLength )
+{
+remain = maxRecordingLength;
+}
+else
+{
+remain = iVideoTimeRemaining;
+}
+}
+PRINT1( _L("Camera <= CCamAppController::RecordTimeRemaining, %Ld" ), remain.Int64() );
+return remain;
+}
+// ---------------------------------------------------------------------------
+// SetNoBurstCancel
+//
+//Set iNoBurstCancel flag which is used to prevent stopping burst
+// when actual burst capture has started after focusing. Flag is
+// used in CancelFocusAndCapture method.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetNoBurstCancel(TBool aValue )
+{
+PRINT1 ( _L("Camera =><= CCamAppController::SetNoBurstCancel, aValue=%d"),aValue );
+	iNoBurstCancel=aValue;
+}
+// ---------------------------------------------------------------------------
+// SoftStopBurstL
+//
+// Stop burst as soon as possible given the following constrains:
+//   - if quick burst is ongoing, it's continued to the end, unless
+//     aFastStop is true. Then the minimum of 2 images is allowed.
+//     For "immediate" stop, StopSequenceCapture should be used.
+//   - if press and hold burst is ongoing, stop after next image.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SoftStopBurstL( TBool aFastStop /*=EFalse*/ )
+{
+PRINT ( _L("Camera => CCamAppController::SoftStopBurstL") );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// Still in short burst mode, if
+// a) no burst timer at all (long burst not supported)
+// b) burst timer still ticking
+// c) in self-timer initiated burst, which is always short burst.
+TBool shortBurst = ( !iBurstTimer
+||  iBurstTimer->IsActive()
+||  appUi->SelfTimerEnabled() );
+PRINT1( _L("Camera <> CCamAppController::SoftStopBurstL .. is short burst: %d"), shortBurst );
+StopBurstTimer();
+if( iSequenceCaptureInProgress )
+{
+PRINT ( _L("Camera <> CCamAppController::SoftStopBurstL .. burst ongoing") );
+if( aFastStop || !shortBurst )
+{
+// Camera controller takes care of setting "high enough" limit.
+// SetCaptureLimitL takes care of setting right count to
+// stop as early as possible.
+SetCaptureLimitL( 0 );
+}
+}
+else if( ECamFocusing != iInfo.iOperation &&
+!iAutoFocusRequested )
+{
+PRINT ( _L("Camera <> CCamAppController::SoftStopBurstL .. burst NOT ongoing, just cancel pending..") );
+iCaptureRequested = EFalse;
+}
+PRINT ( _L("Camera <= CCamAppController::SoftStopBurstL") );
+}
+// ---------------------------------------------------------------------------
+// StartBurstTimerL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StartBurstTimerL()
+{
+PRINT ( _L("Camera => CCamAppController::StartBurstTimerL") );
+if( iBurstTimer )
+{
+StopBurstTimer();
+}
+else
+{
+TInt timeout( 0 );
+User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiLongCaptureKeyPressInterval, timeout ) );
+PRINT1( _L("Camera <> CCamAppController::StartBurstTimerL .. Creating timer with timeout value of [%d ms]"), timeout );
+// Multiply timeout by 1000 to get microseconds
+TCallBack cb( CCamAppController::ShortBurstTimeout, this );
+iBurstTimer = CCamTimer::NewL( timeout*1000, cb );
+}
+PRINT ( _L("Camera <> CCamAppController::StartBurstTimerL .. Starting timer..") );
+iBurstTimer->StartTimer();
+PRINT ( _L("Camera <= CCamAppController::StartBurstTimerL") );
+}
+// ---------------------------------------------------------------------------
+// StopBurstTimer
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StopBurstTimer()
+{
+PRINT( _L("Camera => CCamAppController::StopBurstTimer") );
+if( iBurstTimer )
+{
+iBurstTimer->Cancel();
+}
+PRINT( _L("Camera <= CCamAppController::StopBurstTimer") );
+}
+// ---------------------------------------------------------------------------
+// ShortBurstTimeout
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::ShortBurstTimeout( TAny* aController )
+{
+PRINT( _L("Camera => CCamAppController::ShortBurstTimeout") );
+CCamAppController* self = static_cast<CCamAppController*>( aController );
+TRAP_IGNORE( self->DoShortBurstTimeoutL() );
+PRINT( _L("Camera <= CCamAppController::ShortBurstTimeout") );
+return KErrNone; // no more callbacks
+}
+// ---------------------------------------------------------------------------
+// DoShortBurstTimeoutL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::DoShortBurstTimeoutL()
+{
+PRINT( _L("Camera => CCamAppController::DoShortBurstTimeoutL") );
+PRINT2( _L("Camera <> CCamAppController::DoShortBurstTimeoutL iInfo.iImageMode: %d, iSequenceCaptureInProgress: %d"), iInfo.iImageMode, iSequenceCaptureInProgress );
+if( ECamImageCaptureBurst == iInfo.iImageMode
+&& iSequenceCaptureInProgress )
+{
+TInt longBurstLimit( 0 );
+CamUtility::GetPsiInt( ECamPsiMaxBurstCapture, longBurstLimit );
+PRINT1( _L("Camera <> CCamAppController::DoShortBurstTimeoutL .. product long burst limit: %d"), longBurstLimit );
+SetCaptureLimitL( longBurstLimit );
+}
+PRINT( _L("Camera <= CCamAppController::DoShortBurstTimeoutL") );
+}
+// ---------------------------------------------------------------------------
+// Actual capture limit value.
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CaptureLimit() const
+{
+TInt limit( 1 );
+if( iCameraController && ECamImageCaptureBurst == iInfo.iImageMode )
+{
+limit = iCameraController->ControllerInfo().iCaptureLimit;
+}
+return limit;
+}
+// ---------------------------------------------------------------------------
+// CaptureLimitSetting
+//
+// Stored for Setting Provider to give to Camera Controller.
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CaptureLimitSetting() const
+{
+TInt limit( 1 );
+if( ECamImageCaptureBurst == iInfo.iTargetImageMode )
+{
+limit = iRequestedCaptureCount;
+}
+return limit;
+}
+// ---------------------------------------------------------------------------
+// SetCaptureLimitL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetCaptureLimitL( TInt aLimit )
+{
+PRINT1( _L("Camera => CCamAppController::SetCaptureLimitL .. requested limit: %d"), aLimit );
+if( ECamImageCaptureBurst == iInfo.iTargetImageMode )
+{
+PRINT ( _L("Camera <> CCamAppController::SetCaptureLimitL .. burst mode active") );
+// We give the total amount of images during burst, not the remaining ones.
+// Need to subtract captures that have already been taken,
+// before comparing to the disk limit.
+if( iSequenceCaptureInProgress )
+{
+//TInt captured  = iCameraController->ControllerInfo().iCaptureCount;
+TInt captured  = iCameraController->ControllerInfo().iSnapshotCount;
+PRINT1( _L("Camera <> CCamAppController::SetCaptureLimitL .. captured already: %d"), captured );
+if( aLimit > captured )
+{
+PRINT ( _L("Camera <> CCamAppController::SetCaptureLimitL .. some more captures requested..") );
+// Check which is more restrictive - disk space or given limit.
+TInt diskLimit = ImagesRemaining( ECamMediaStorageCurrent, ETrue );
+TInt remaining = Min( aLimit - captured, diskLimit );
+PRINT1( _L("Camera <> CCamAppController::SetCaptureLimitL .. disk limit: %d"), diskLimit );
+iRequestedCaptureCount = Max( KMinBurstCount, captured + remaining );
+if ( diskLimit - KMinBurstCount < iRequestedCaptureCount )
+{
+// Estimated file size is not worst case estimate and long burst
+// sequence accumulates error, thus critical disk space limit may
+// be reached. Requested capture count is decreased here if needed.
+iRequestedCaptureCount -=
+(iRequestedCaptureCount+KMinBurstCount)/KBurstEstimate;
+PRINT( _L("Camera <> CCamAppController::SetCaptureLimitL .. Near to critical level, adjust iRequestedCaptureCount"));
+}
+}
+else
+{
+PRINT ( _L("Camera <> CCamAppController::SetCaptureLimitL .. capturing should be stopped as soon as possible..") );
+// Stop as fast as possible requested.
+// Still need to request minimum of 2.
+iRequestedCaptureCount = Max( KMinBurstCount, captured + 1 );
+}
+}
+// Not capturing - adjust freely
+else
+{
+TInt diskLimit = ImagesRemaining( ECamMediaStorageCurrent, ETrue );
+PRINT1( _L("Camera <> CCamAppController::SetCaptureLimitL .. disk limit: %d"), diskLimit );
+iRequestedCaptureCount = Max( KMinBurstCount, Min( aLimit, diskLimit ) );
+}
+PRINT1( _L("Camera <> CCamAppController::SetCaptureLimitL .. setting the request limit to: %d"), iRequestedCaptureCount );
+// In burst mode camera needs to be updated with the limit.
+iCameraController->DirectSettingsChangeL( ECameraSettingCaptureLimit );
+}
+else
+{
+PRINT ( _L("Camera <> CCamAppController::SetCaptureLimitL .. single / timelapse mode active") );
+TInt diskLimit = ImagesRemaining( ECamMediaStorageCurrent, EFalse );
+PRINT1( _L("Camera <> CCamAppController::SetCaptureLimitL .. disk limit: %d"), diskLimit );
+iRequestedCaptureCount = Min( aLimit, diskLimit );
+PRINT1( _L("Camera <> CCamAppController::SetCaptureLimitL .. setting the request limit to: %d"), iRequestedCaptureCount );
+}
+PRINT ( _L("Camera <= CCamAppController::SetCaptureLimitL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetTimeLapseInterval
+// Updates the interval used in next TimeLapse capture
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetTimeLapseInterval( TTimeIntervalMicroSeconds aInterval )
+{
+iTimeLapseInterval = aInterval;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TimeLapseInterval
+// Returns the interval used in next TimeLapse capture
+// ---------------------------------------------------------------------------
+//
+TTimeIntervalMicroSeconds CCamAppController::TimeLapseInterval()
+{
+return iTimeLapseInterval;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TimeLapseCountdown
+// Returns the remaining time lapse interval until the next capture
+// ---------------------------------------------------------------------------
+//
+TTimeIntervalMicroSeconds CCamAppController::TimeLapseCountdown()
+{
+TInt64 remainingTime( 0 );    // Assume uninitialised start time
+// If the start time is uninitialised then the first capture is about to be initiated
+if ( iTimeLapseStartTime == remainingTime )
+{
+return remainingTime;
+}
+// Otherwise, work out how much time is left before the next capture
+TTime now;
+now.HomeTime();
+TTimeIntervalMicroSeconds elapsedTime = now.MicroSecondsFrom( iTimeLapseStartTime );
+remainingTime = Max ( remainingTime, iTimeLapseInterval.Int64() - elapsedTime.Int64() );
+return remainingTime;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StartAutoFocus
+// Start the autofocus procedure
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StartAutoFocus()
+{
+PRINT (_L("Camera => CCamAppController::StartAutoFocus"));
+PRINT1(_L("Camera <> CCamAppController::StartAutoFocus - CurrentOperation() = [%s]"), KCamCaptureOperationNames[iInfo.iOperation] );
+PRINT1(_L("Camera <> CCamAppController::StartAutoFocus - IsViewFinding()    = [%d]"), IsViewFinding() );
+if( iConfigManager
+&& iConfigManager->IsAutoFocusSupported()
+&& IsViewFinding()
+&& !iAFCancelInProgress
+&& ECamNoOperation == iInfo.iOperation )
+{
+PRINT(_L("Camera <> Calling TryAutoFocus" ) );
+TryAutoFocus();
+}
+PRINT(_L("Camera <= CCamAppController::StartAutoFocus"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::Capture
+// Begin the capture procedure
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::Capture()
+{
+PRINT2( _L("Camera => CCamAppController::Capture(), operation[%s], iSaving:%d"),
+KCamCaptureOperationNames[iInfo.iOperation],
+iSaving );
+// If the camera orientation changed during capture and not in burst mode,
+// set the new orientation
+if ( iConfigManager && iConfigManager->IsOrientationSensorSupported()
+&& iOrientationChangeOccured
+&& iInfo.iImageMode != ECamImageCaptureBurst )
+{
+iOrientationChangeOccured = EFalse;
+TRAP_IGNORE( SetImageOrientationL() );
+}
+if( iConfigManager && iConfigManager->IsOrientationSensorSupported() && !iAccSensorListening )
+{
+// Delayed sensor initialization has not yet happened, but shutter key has been pressed.
+// Force initialization now, causing an addition to shutter lag - this is a very
+// rare case, as there should always be enough idle time to run the delayed
+// initialization.
+TRAP_IGNORE( UpdateSensorApiL( ETrue ) );
+}
+PERF_EVENT_END_L1( EPerfEventKeyToCapture );
+// Set to EFalse for burst
+iAllSnapshotsReceived = EFalse;
+if ( ECamFocusing == iInfo.iOperation ||
+iAFCancelInProgress ||
+iAutoFocusRequested || IsAfNeeded() )
+{
+PRINT( _L("Camera <> Focusing going on, cannot start capture - setting iCaptureRequested" ) );
+if( !IsAfNeeded() )
+{
+CancelAFNow();
+}
+iCaptureRequested = ETrue;
+}
+// -------------------------------------------------------
+//Quick pressed capture key after backing to precapture from postcapture in burst mode
+//Quick pressed capture key during cancelling autofocus(eg. backing to precapture from setting view )
+else if ( ECamNoOperation == iInfo.iOperation
+&& ( ( ECamImageCaptureTimeLapse == iInfo.iImageMode )
+|| ( ECamImageCaptureBurst == iInfo.iImageMode )
+|| ( ECamImageCaptureSingle == iInfo.iImageMode ) )
+&& iAFCancelInProgress )
+{
+PRINT(_L("Camera <> Cancelling auto focus going on, cannot start capture - setting iCaptureRequested"));
+// delay the start of capture until cancelling autofocus has finished
+iCaptureRequested = ETrue;
+}
+// -------------------------------------------------------
+// Quick pressed after capture, during image processing
+else if ( ECamCompleting         == iInfo.iOperation
+&& ECamImageCaptureSingle == iInfo.iImageMode )
+{
+PRINT(_L("Camera <> operation state is capture completing setting iCaptureRequested"));
+// delay the start of capture until current capture has finished
+iCaptureRequested = ETrue;
+}
+// -------------------------------------------------------
+// Ready for new shot
+else if( ECamNoOperation == iInfo.iOperation
+|| ECamFocused     == iInfo.iOperation
+|| ECamFocusFailed == iInfo.iOperation )
+{
+PRINT(_L("Camera <> operation state is no operation"));
+// Update current capture mode
+//    iInfo.iImageMode = CurrentImageModeSetup();
+if ( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+// If AF sound hasn't finished playing yet, stop it now
+// to make sure it does not block capture sound playing.
+iSoundPlayer->CancelPlaying( ECamAutoFocusComplete );
+}
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+if( ECamImageCaptureBurst != iInfo.iImageMode )
+{
+// Do not log the single image start events in burst mode, as the end
+// events would arrive for all images at once after all images have been taken
+PERF_EVENT_START_L1( EPerfEventShotToSnapshot );
+PERF_EVENT_START_L1( EPerfEventShotToStillImageReady );
+PERF_EVENT_START_L1( EPerfEventShotToSave );
+}
+else
+{
+PERF_EVENT_START_L1( EPerfEventSequenceCapture );
+}
+#endif // CAMERAAPP_PERFORMANCE_MEASUREMENT
+if( ECamImageCaptureTimeLapse == iInfo.iImageMode &&
+!iSequenceCaptureInProgress )
+{
+// First image of timelapse, reset capture count
+iTimeLapseCaptureCount = 0;
+}
+if( iInfo.iImageMode == ECamImageCaptureNone )
+{
+PRINT(_L("Camera <= CCamAppController::Capture() - request ignored"));
+return;
+}
+// iCaptureRequested is reset in DoCaptureL
+TBool capture = EFalse;
+TInt err = KErrNone;
+iFilenameReserved = EFalse;
+TRAP( err, capture = DoCaptureL() );
+if ( KErrNone != err )
+{
+// Sequence capture is not in progress as capture failed
+iSequenceCaptureInProgress = EFalse;
+}
+PRINT1( _L("Camera <> Tried to start capture, status:%d"), capture );
+if ( capture )
+{
+if( ECamActiveCameraPrimary == iInfo.iActiveCamera
+&& iConfigManager && iConfigManager->IsCaptureToneDelaySupported() )
+{
+// first cancel to make sure
+iCaptureToneDelayTimer->Cancel();
+// delay playing of capture tone
+iCaptureToneDelayTimer->StartTimer();
+}
+else
+{
+// Play capture sound
+PlaySound( CaptureToneId(), EFalse );
+}
+}
+}
+// -------------------------------------------------------
+// Not ready for a capture
+else
+{
+// request ignored
+}
+// -------------------------------------------------------
+PRINT(_L("Camera <= CCamAppController::Capture()"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StopSequenceCaptureL
+// Stop and complete the burst capture operation
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StopSequenceCaptureL()
+{
+PRINT( _L("Camera => CCamAppController::StopSequenceCaptureL()") );
+iSequenceCaptureInProgress = EFalse;
+iNoBurstCancel = EFalse;
+// Re-enable screen saver
+EnableScreenSaver( ETrue );
+TCamImageCaptureMode captureModeSetup = CurrentImageModeSetup();
+// Test that this method was not called in single capture mode
+__ASSERT_DEBUG( captureModeSetup != ECamImageCaptureSingle, CamPanic( ECamPanicInvalidState ) );
+// If a burst sequence is currently active or has been requested
+if ( iInfo.iImageMode == ECamImageCaptureBurst
+|| ( captureModeSetup == ECamImageCaptureBurst && iCaptureRequested ) )
+{
+IssueDirectRequestL( ECamRequestImageCancel );
+if ( iInfo.iOperation != ECamCapturing )
+{
+CompleteBurstOperation();
+}
+}
+// If a timelapse sequence is currently active or has been requested
+else if ( iInfo.iImageMode == ECamImageCaptureTimeLapse ||
+( captureModeSetup == ECamImageCaptureTimeLapse &&
+iCaptureRequested ) )
+{
+if ( TimeLapseSupported() )
+{
+if ( iTimeLapseTimer )
+{
+iTimeLapseTimer->Cancel();
+delete iTimeLapseTimer;
+iTimeLapseTimer = NULL;
+}
+// The current state is in between captures the next one has now been cancelled
+// so just ensure that the view switch occurs
+// if ( iInfo.iOperation != ECamCapturing && !iCaptureRequested )
+if ( iInfo.iOperation != ECamCapturing )
+{
+CompleteTimeLapseOperation();
+}
+// Either the first capture is queued or a capture is still in stages of
+// completion. Any future capture has been cancelled so all that remains is to ensure the
+// completion code is run when the capture finally completes
+else
+{
+iCompleteTimeLapsePending = ETrue;
+}
+}
+}
+else // Otherwise there is no active or pending burst
+{
+// Do nothing
+}
+PRINT( _L("Camera <= CCamAppController::StopSequenceCaptureL()") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CapturePending
+// Whether or not a capture is pending
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::CapturePending() const
+{
+// iOperation can be ECamFocusing but a
+// request to start still capture has been made and is waiting for the
+// focus operation to complete
+return iCaptureRequested;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::VideoRecordPending
+// Whether or not video recording is pending
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::VideoRecordPending() const
+{
+// iOperation can be ECamFocusing but a
+// request to start video has been made and is waiting for the
+// focus operation to complete
+return iVideoRequested;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SequenceCaptureInProgress
+// Whether or not sequence capture is active
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::SequenceCaptureInProgress() const
+{
+return iSequenceCaptureInProgress;
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::StartVideoRecordingL
+// Begin the video recording procedure
+// -----------------------------------------------------------------------------
+//
+void CCamAppController::StartVideoRecordingL()
+{
+PRINT( _L("Camera => CCamAppController::StartVideoRecordingL") );
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicInvalidState ) );
+if( ECamControllerVideo == iInfo.iMode )
+{
+if( !iVideoRequested
+&&  ECamNoOperation == iInfo.iOperation )
+{
+iVideoRequested = ETrue;
+if( !iSilentProfile || iShutterSndAlwaysOn  )
+	{
+	// Load (and play) the start video sound
+	PlaySound( ECamVideoStartSoundId , ETrue );
+	}
+// initialise the array accessing values
+iArrayUsageCount   = KVideoArrayUsers;
+iCurrentImageIndex = 0;
+if( ECamMediaStorageCard ==
+IntegerSettingValue( ECamSettingItemVideoMediaStorage ) )
+{
+TRAPD( err, ReserveFileNamesL( iInfo.iMode, ECamImageCaptureNone ) );
+if ( err )
+{
+PRINT( _L("Camera <> invalid MMC") );
+NotifyControllerObservers( ECamEventInvalidMemoryCard );
+// If we have got here, we can't access MMC. Switch to phone memory
+TRAP_IGNORE( ForceUsePhoneMemoryL() ); //with multiple drive support,
+//this actually uses the internal mass memory
+// Ignore for now, let fail when recording.
+TRAP_IGNORE( ReserveFileNamesL( iInfo.iMode, ECamImageCaptureNone, ETrue ) );
+}
+}
+else
+{
+// Ignore for now, let fail when recording.
+TRAP_IGNORE( ReserveFileNamesL( iInfo.iMode, ECamImageCaptureNone ) );
+}
+if( iSilentProfile && !iShutterSndAlwaysOn )
+	{
+	PlaySoundComplete();
+	}
+// Remember where are we recording
+iInitialVideoStorageLocation = static_cast<TCamMediaStorage>(
+IntegerSettingValue( ECamSettingItemVideoMediaStorage ) );
+}
+else
+{
+// Video already requested or other operation busy.
+// Request ignored.
+}
+}
+// Note: The code to actually START video recording has been moved
+// to the PlaySoundComplete function so as to only start when
+// sound playback has completed.
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StopVideoRecording
+// End the video recording procedure
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StopVideoRecording()
+{
+PRINT( _L("Camera => CCamAppController::StopVideoRecording") );
+// if a video capture operation is pending
+if ( iVideoRequested )
+{
+iVideoRequested = EFalse;
+}
+// otherwise, if a video recording operation is in progress or is paused
+/*  else */
+if ( ECamCapturing == CurrentVideoOperation()
+|| ECamPaused    == CurrentVideoOperation() )
+{
+//  TRAPD( err, iAutoFocus->StopContinuousFocusL() );
+//  iFocusLocked = EFalse;
+// Keep track of the fact we are now in "saving" state
+iSaving = ETrue;
+TRAP_IGNORE(
+{
+// IssueDirectRequestL( ECamRequestVfStop );
+StopViewFinder();
+IssueRequestL( ECamRequestVideoStop ); // Rest handled when event comes.
+});
+StartIdleTimer();
+}
+else
+{
+// otherwise there is no current recording operation
+}
+PRINT( _L("Camera <= CCamAppController::StopVideoRecording") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StopVideoRecordingAsync
+// End the video recording procedure asynchronously
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StopVideoRecordingAsync()
+{
+PRINT( _L("Camera => CCamAppController::StopVideoRecordingAsync") );
+// Change CAE and MMF mode to async
+TRAP_IGNORE( IssueRequestL( ECamRequestSetAsyncVideoStopMode ) );
+StopVideoRecording();  // Call normal stop, mode is set to sync in call-backs
+PRINT( _L("Camera <= CCamAppController::StopVideoRecordingAsync") );
+}
+// ---------------------------------------------------------------------------
+// HandleVideoAsyncStopEvent
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleVideoAsyncStopEvent( TInt aStatus )
+{
+PRINT1( _L( "Camera => CCamAppController::HandleVideoAsyncStopEvent, status:%d" ), aStatus );
+(void)aStatus; // remove compiler warning
+// We DO NOT play the stop sound when recording stopped due to
+// an incoming call.  UI Spec 1.0, 4.4.1.
+if ( !iInCallOrRinging
+&& !iVideoStoppedForPhoneApp )
+{
+PlaySound( ECamVideoStopSoundId, EFalse ); // No callback
+}
+// Recording completed, so we can re-enable key sounds
+iSoundPlayer->EnableAllKeySounds();
+PRINT( _L( "Camera <= CCamAppController::HandleVideoAsyncStopEvent" ) );
+}
+// ---------------------------------------------------------------------------
+// HandleVideoStopEvent
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleVideoStopEvent( TInt aStatus )
+{
+PRINT1( _L( "Camera => CCamAppController::HandleVideoStopEvent, status:%d" ), aStatus );
+PERF_EVENT_END_L1( EPerfEventVideoStopToSave );
+if ( KErrDiskFull   == aStatus
+|| KErrCompletion == aStatus)
+{
+// if recording ends due to disk full condition or end of
+// specified recording period do not propogate the error
+aStatus = KErrNone;
+}
+// Play sound here if async mode is not supported
+// If it is then next playing is copyed to HandleVideoAsyncStopEvent
+if ( iCameraController && !iCameraController->AsyncVideoStopModeSupported() )
+{
+// We DO NOT play the stop sound when recording stopped due to
+// an incoming call.  UI Spec 1.0, 4.4.1.
+if ( !iInCallOrRinging
+&& !iVideoStoppedForPhoneApp )
+{
+PlaySound( ECamVideoStopSoundId, EFalse ); // No callback
+}
+// Recording completed, so we can re-enable key sounds
+iSoundPlayer->EnableAllKeySounds();
+}
+// Keep track of the fact we are now leaving saving state
+iSaving = EFalse;
+// try closing video record to free up resources
+// Test - <eo> commented out, no such direct request supported
+// TRAP_IGNORE( IssueDirectRequestL( ECamRequestVideoRelease ) );
+// if video post capture is off then force re-prepare so
+// that remaining record time is updated
+// REMOVED
+// if using direct viewfinding pause viewfinder
+// REMOVED
+// report to LifeBlog
+RProperty::Set( KPSUidCamcorderNotifier, KCamLatestFilePath, iSuggestedVideoPath );
+// Add to album if this is enabled for videos
+TUint32 defaultAlbumId = static_cast<TUint32>(
+IntegerSettingValue( ECamSettingItemDefaultAlbumId ));
+if ( iSettingsModel->IntegerSettingValue
+( ECamSettingItemVideoStoreInAlbum ) == ECamSettYes )
+{
+iImageSaveActive->AddToAlbum( iSuggestedVideoPath, ETrue, defaultAlbumId );
+}
+else // Harvest the file but dont add to the default album
+{
+iImageSaveActive->AddToAlbum( iSuggestedVideoPath, EFalse, defaultAlbumId );
+}
+//create thumbnail
+if( iConfigManager && iConfigManager->IsThumbnailManagerAPISupported() )
+{
+TRAP_IGNORE( iImageSaveActive->CreateThumbnailsL( *BurstCaptureArray() ) );
+}
+NotifyControllerObservers( ECamEventRecordComplete,   aStatus );
+SetOperation( ECamNoOperation );
+PRINT( _L( "Camera <> calling HandleCaptureCompletion.." ) )
+HandleCaptureCompletion();
+NotifyControllerObservers( ECamEventMediaFileChanged, aStatus );
+PRINT( _L( "Camera <= CCamAppController::HandleVideoStopEvent" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetVideoStoppedForPhoneApp
+// Store the cause of the video stopping
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetVideoStoppedForPhoneApp( TBool aIsPhoneApp )
+{
+iVideoStoppedForPhoneApp = aIsPhoneApp;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PauseVideoRecording
+// Pause the video recording procedure
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::PauseVideoRecording()
+{
+PRINT( _L("Camera => CCamAppController::PauseVideoRecording") );
+if( ECamCapturing == CurrentVideoOperation() )
+{
+TRAPD( error, IssueRequestL( ECamRequestVideoPause ) );
+if( KErrNone != error )
+{
+PRINT( _L("Camera <> PAUSING FAILED!!") );
+}
+else
+{
+// start video pause timeout
+StartIdleTimer();
+}
+}
+PRINT( _L("Camera <= CCamAppController::PauseVideoRecording") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ContinueVideoRecording
+// Continue the video recording procedure
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ContinueVideoRecording()
+{
+PRINT( _L("Camera => CCamAppController::ContinueVideoRecording") );
+if ( ECamPaused == CurrentVideoOperation() )
+{
+SetOperation( ECamResuming );
+// Restart video when sound played
+PlaySound( ECamVideoResumeSoundId, ETrue );
+}
+PRINT( _L("Camera <= CCamAppController::ContinueVideoRecording") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TryAFRequest
+// issue AF request if there are no pending AF requests currently
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::TryAFRequest( TInt aAFRequest )
+{
+PRINT( _L( "Camera => TryAFRequest") );
+PRINT3( _L( "iPendingAFRequest=%d aAFRequest=%d ,iCurrentAFRequest=%d"), iPendingAFRequest,
+aAFRequest, iCurrentAFRequest );
+switch( aAFRequest )
+{
+case  ECamRequestCancelAutofocus:
+case ECamRequestStartAutofocus:
+{
+if(iPendingAFRequest==0)
+{
+if ( !( UiConfigManagerPtr()->IsContinuosAutofocusSupported()&& ECamControllerVideo == CurrentMode() ) )
+{
+iPendingAFRequest=aAFRequest;
+TRAPD( err, IssueDirectRequestL( TCamCameraRequestId(aAFRequest) ) );
+//TRAPD( err, iCameraController->DirectRequestL( aAFRequest ) );
+if ( err != KErrNone )
+{
+// There is an error, we leave without focusing
+iPendingAFRequest=0;
+return EFalse; // Not doing any autofocus request.
+//This is only case where AFrequest cause EFalse to be returned.
+}
+}
+}
+else
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi->AlwaysDrawPreCaptureCourtesyUI()
+&& !CurrentSceneHasForcedFocus() )
+{
+appUi->SetActivePaletteVisibility( EFalse );
+}
+iPendingAFRequest=aAFRequest;
+}
+}
+break;
+default:
+{
+//Not type of autofocus request. Ignoring.
+}
+break;
+}
+PRINT( _L( "Camera <= TryAFRequest") );
+return ETrue;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CancelAFNow
+// Cancel AutoFocus
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CancelAFNow()
+{
+PRINT( _L("Camera => CCamAppController::CancelAfNow()") );
+if( !iAFCancelInProgress && ECamFocusing == CurrentOperation() )
+{
+TRAPD( err, IssueDirectRequestL( ECamRequestCancelAutofocus ) );
+if( KErrNone == err )
+{
+iAFCancelInProgress = ETrue;
+iCurrentAFRequest = ECamRequestCancelAutofocus;
+iPendingAFRequest = ECamRequestCancelAutofocus;
+}
+}
+else
+{
+PRINT( _L("AF Cancel already in progress or not focusing") );
+}
+PRINT( _L("Camera <= CCamAppController::CancelAfNow()") );
+}
+// CCamAppController::CancelFocusAndCapture
+// Cancel the focus and capture procedures
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CancelFocusAndCapture()
+{
+PRINT( _L( "Camera => CCamAppController::CancelFocusAndCapture") );
+PRINT1( _L("Camera <> CCamAppController::CancelFocusAndCapture - CurrentOperation() = [%s]"), KCamCaptureOperationNames[iInfo.iOperation] );
+PRINT1( _L("Camera <> CCamAppController::CancelFocusAndCapture - IsViewFinding()    = [%d]"), IsViewFinding() );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// Only cancels autofocus if needed, burst capture is no longer
+// stopped if capture key pressed during burst
+if( !iNoBurstCancel
+&& ECamNoOperation != CurrentOperation()
+&& ECamCompleting  != CurrentOperation() )
+{
+// If we are currently focused, cancel autofocus
+if ( IsViewFinding() && CurrentOperation() != ECamCapturing ) // Cannot do AF operations if VF not on. AF is anyway cancelled on VF start event.
+{
+if( ECamFocusing == CurrentOperation() )
+{
+CancelAFNow();
+if ( IsTouchScreenSupported() )
+{
+CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();
+if ( fixedToolbar )
+{
+fixedToolbar->SetToolbarVisibility( ETrue );
+}
+}
+}
+else
+{
+TryAFRequest( ECamRequestCancelAutofocus );
+}
+}
+iCaptureRequested = EFalse;
+}
+PRINT( _L( "Camera <= CCamAppController::CancelFocusAndCapture") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SnapshotImage
+// Get post-exposure snapshot bitmap, if available.
+//
+// Returns: pointer to post-exposure snapshot bitmap. Does not transfer ownership.
+//          May be NULL if no image available.
+//
+// ---------------------------------------------------------------------------
+//
+const CFbsBitmap*
+CCamAppController::SnapshotImage() const
+{
+PRINT ( _L("Camera => CCamAppController::SnapshotImage") );
+PRINT1( _L("Camera <> CCamAppController::SnapshotImage .. current image index: %d"), iCurrentImageIndex );
+PRINT1( _L("Camera => CCamAppController::SnapshotImage .. saved current image: %d"), SavedCurrentImage() );
+//Sometime burst capture array includes more than one image in single capture mode,
+//so just display the latest image here.
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( BurstCaptureArray()->Count() > 1 && !appUi->IsBurstEnabled() )
+{
+TInt currentImageIndex = BurstCaptureArray()->Count() - 1;
+const CFbsBitmap* ss = BurstCaptureArray()->Snapshot( currentImageIndex );
+PRINT( _L("Camera <= CCamAppController::SnapshotImage") );
+return ss;
+}
+const CFbsBitmap* ss = BurstCaptureArray()->Snapshot( iCurrentImageIndex );
+PRINT( _L("Camera <= CCamAppController::SnapshotImage") );
+return ss;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetAsCurrentImage
+// Sets the specified index as the "current image", as will be used by the
+// post capture view
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetAsCurrentImage( TInt aIndex )
+{
+iCurrentImageIndex = aIndex;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentImageName
+// Get the user-visible name for the current image
+// used in post-capture views.
+// ---------------------------------------------------------------------------
+//
+const TDesC&
+CCamAppController::CurrentImageName() const
+{
+return BurstCaptureArray()->ImageName( iCurrentImageIndex );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::BurstCaptureArray
+// Return a pointer to the array representing a burst capture
+// ---------------------------------------------------------------------------
+//
+CCamBurstCaptureArray*
+CCamAppController::BurstCaptureArray() const
+{
+return iCaptureArray;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentItemCount
+// Return the count of non-deleted items in the burst array
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CurrentItemCount()
+{
+if ( !BurstCaptureArray() )
+{
+return 0;
+}
+return BurstCaptureArray()->ImagesRemaining();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentCapturedCount
+// Return the count of burst capture moments that have taken
+// place in a current burst
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CurrentCapturedCount()
+{
+//return iActualBurstCount;
+TInt count( 0 );
+if( iCameraController )
+{
+// Using snapshot as count, because UI updates counter
+// on snapshot events.
+count = iCameraController->ControllerInfo().iSnapshotCount;
+}
+return count;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TimeLapseImageCount
+// Return the count of items in the timelapse sequence array
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::TimeLapseImageCount()
+{
+return iTimeLapseCaptureCount;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ResetTimelapseArray
+// Resets the timelapse sequence array
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ResetTimelapseArray()
+{
+iSequenceFilenameArray->Reset();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PlaySound
+// Play a sound with given id.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::PlaySound( TCamSoundId aSoundId, TBool aEnableCallback )
+{
+PRINT1( _L("Camera => CCamAppController::PlaySound %d"), aSoundId );
+if ( ToneShouldBeSilent( aSoundId ) &&
+!iShutterSndAlwaysOn &&
+iSilentProfile )
+{
+PRINT( _L("Camera <> Profile silent, do not play sound") );
+// Don't play shutter sound if we are following
+// current profile setting and profile is silent.
+// Notify the observer right away. E.g. video start
+// depends on the notification
+if( aEnableCallback )
+{
+PlayComplete( aSoundId, KErrNone );
+}
+/* OLD
+if ( aSoundId == ECamVideoStartSoundId ||
+aSoundId == ECamVideoPauseSoundId ||
+aSoundId == ECamVideoResumeSoundId )
+{
+// Force the callback to start recording without sound.
+PlaySoundComplete();
+}
+*/
+}
+else
+{
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_PLAYSOUND, "e_CAM_APP_CAPTURE_SOUND_PLAY 1" );   //CCORAPP_CAPTURE_SOUND_PLAY_START
+iSoundPlayer->CancelAllPlaying();
+iSoundPlayer->PlaySound( aSoundId, aEnableCallback );
+}
+// If in timelapse mode the remaining time counter should be updated
+// as soon as the capture tone has played, but as there is no callback
+// this is the closest we can get
+if ( ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+NotifyControllerObservers( ECamEventCounterUpdated );
+}
+PRINT( _L("Camera <= CCamAppController::PlaySound") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PlayTone
+// Play a tone with specified frequency, period and volume
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::PlayTone( TInt      aToneHz,
+TInt      aLenMicSec,
+TReal32   aVolume,
+TBool     aEnableCallback )
+{
+if ( !iShutterSndAlwaysOn &&
+iSilentProfile )
+{
+// don't play shutter sound if we are following
+// current profile setting and profile is silent
+}
+else
+{
+iSoundPlayer->PlayTone( aToneHz, aLenMicSec, aVolume, aEnableCallback );
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::AllOptionsVisibleForSettingItem
+// Returns true if all the settings list options for a particular setting
+// item are visible.
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::AllOptionsVisibleForSettingItem( TInt aSettingItem,
+TInt& aRevisedResourceId )
+{
+if ( ( aSettingItem == ECamSettingItemVideoQuality ) &&
+( iInfo.iActiveCamera == ECamActiveCameraSecondary ) )
+{
+aRevisedResourceId = ROID(R_CAM_FRONT_CAMERA_VIDEO_QUALITY_TEXT_ARRAY);
+return EFalse;
+}
+// Otherwise, all options are visible for the setting item
+return ETrue;
+}
+// ----------------------------------------------------
+// CCamAppController::SwitchCameraL
+// Switch the camera
+// ----------------------------------------------------
+//
+void CCamAppController::SwitchCameraL()
+{
+PRINT( _L("Camera => CCamAppController::SwitchCameraL") );
+TCamAppControllerInfo oldInfo      = iInfo;
+TCamActiveCamera      targetCamera = ECamActiveCameraNone;
+// If something goes wrong when changing from 2nd to 1st camera,
+// we need to make sure, that 2nd cam settings are not stored
+// to CR by accident.
+iInfo = TCamAppControllerInfo(); // reset
+// reset zoom waiting flag. this flag is only used with bitmap viewfinder
+// and it might cause problems if one camera uses bitmap viewfinder and the
+// other one uses direct viewfinder
+iZoomWaitingForCamera = EFalse;
+CancelPreviewChangesL();
+if( ECamActiveCameraPrimary == oldInfo.iActiveCamera )
+{
+// Currently using primary camera, switch to secondary
+PRINT( _L("Camera <> switch to 2nd cam") );
+#ifdef _DEBUG
+PRINT ( _L("Camera <> ======================================") );
+PRINT ( _L("Camera <> Photo quality index:                  ") );
+PRINT1( _L("Camera <> Before loading 2nd cam settings: %d   "), IntegerSettingValue( ECamSettingItemPhotoQuality ) );
+#endif
+LoadSecondaryCameraSettingsL();
+#ifdef _DEBUG
+PRINT1( _L("Camera <> After loading 2nd cam settings:  %d   "), IntegerSettingValue( ECamSettingItemPhotoQuality ) );
+PRINT ( _L("Camera <> ======================================") );
+#endif
+targetCamera = ECamActiveCameraSecondary;
+}
+else
+{
+// Currently using secondary camera, switch to primary
+// or landscape secondary camera
+PRINT( _L("Camera <> switch to 1st camera or change 2nd camera mode") )
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( appUi->IsEmbedded() )
+{
+LoadStaticSettingsL( appUi->IsEmbedded() );
+}
+else if ( CameraSwitchQueued() != ESwitchSecondaryOrientation )
+{
+iSettingsModel->RestorePrimaryCameraSettingsL();
+}
+if ( CameraSwitchQueued() != ESwitchSecondaryOrientation )
+{
+PRINT( _L("Camera <> switch to 1st cam") )
+targetCamera = ECamActiveCameraPrimary;
+}
+else
+{
+PRINT( _L("Camera <> change 2nd camera mode") )
+targetCamera = ECamActiveCameraSecondary;
+}
+}
+SetCameraSwitchRequired( ESwitchDone );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+iCameraController->SwitchCameraL( (ECamActiveCameraPrimary == targetCamera) ? 0 : 1 );
+iCameraController->CompleteSwitchCameraL();
+// Camera switched.
+// a) Set current camera index to the new one.
+// b) Set target mode (video/image) to the one before mode switch.
+// c) Image mode is single shot after camera switch
+// d) Ensure vf start
+iInfo.iActiveCamera    = targetCamera; // a)
+iInfo.iTargetMode      = appUi->TargetMode(); // b)
+iInfo.iTargetImageMode = ( ECamControllerVideo==iInfo.iTargetMode )
+? ECamImageCaptureNone : ECamImageCaptureSingle; // c)
+iInfo.iTargetVfState   = ECamTriActive; // d)
+if( oldInfo.iMode != ECamControllerShutdown )
+	{
+	IssueModeChangeSequenceL();
+	}
+appUi->SetDrawPreCaptureCourtesyUI( ETrue );
+NotifyControllerObservers( ECamEventCameraChanged );
+PRINT( _L("Camera <= CCamAppController::SwitchCameraL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ActiveCamera
+// Returns the active camera
+// ---------------------------------------------------------------------------
+//
+TCamActiveCamera
+CCamAppController::ActiveCamera() const
+{
+return iInfo.iActiveCamera;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CameraSwitchQueued
+// Returns whether a camera switch is pending
+// ---------------------------------------------------------------------------
+//
+TCameraSwitchRequired
+CCamAppController::CameraSwitchQueued() const
+{
+PRINT1( _L("Camera =><= CCamAppController::CameraSwitchQueued %d"), iCameraSwitchRequired )
+return iCameraSwitchRequired;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CheckExitStatus
+// Check whether exit is required
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::CheckExitStatus()
+{
+PRINT( _L("Camera => CCamAppController::CheckExitStatus" ) )
+TBool exit = EFalse;
+if ( iEndKeyWaiting )
+{
+exit = ETrue;
+}
+else if ( iConfigManager  && iConfigManager->IsLensCoverSupported() )
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( iSliderCloseEvent && !appUi->IsEmbedded() && !appUi->Embedding() )
+{
+PRINT( _L("Camera <> CCamAppController::CheckExitStatus - slider closed, not embedded/embedding" ) )
+exit = ETrue;
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController::CheckExitStatus - embedded/embedding, not exiting" ) )
+exit = EFalse;
+}
+}
+else
+{
+exit = EFalse;
+}
+PRINT1( _L("Camera <= CCamAppController::CheckExitStatus - return %d" ), exit )
+return exit;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetEndKeyExitWaiting
+// Update whether exit is required
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetEndKeyExitWaiting( TBool aEndKeyWaiting )
+{
+iEndKeyWaiting = aEndKeyWaiting;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CameraSlideState
+// Returns the status of the camera slide
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CameraSlideState() const
+{
+return iSlideState;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SliderCloseEventActioned
+// Update whether exit is required
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SliderCloseEventActioned()
+{
+iSliderCloseEvent = EFalse;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetCameraSwitchRequired
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetCameraSwitchRequired( TCameraSwitchRequired aSwitchRequired )
+{
+iCameraSwitchRequired = aSwitchRequired;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CheckSlideStatus
+// Check the slide state and schedule a camera switch if needed
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CheckSlideStatus()
+{
+PRINT( _L("Camera => CCamAppController::CheckSlideStatus") );
+// if only 1 camera available then can't switch camera
+if ( CamerasAvailable() <= 1 )
+{
+PRINT( _L("Camera <> Only one camera, no action") );
+}
+else
+{
+RefreshSlideStatus();
+// if the slide is closed then schedule a camera switch
+// if the back camera is active
+if ( CameraSlideState() == CameraPlatPSKeys::EClosed  ||
+CameraSlideState() == KErrNone )
+{
+if ( iInfo.iActiveCamera == ECamActiveCameraPrimary )
+{
+PRINT( _L("Camera <> slide closed or uninitialized -> switch to secondary") );
+iCameraSwitchRequired = ESwitchPrimaryToSecondary;
+}
+else
+{
+PRINT( _L("Camera <> no camera switch needed") );
+iCameraSwitchRequired = ESwitchDone;
+}
+}
+// if the slide is open then schedule a camera switch
+// if the front camera is active
+else if ( CameraSlideState() == CameraPlatPSKeys::EOpen )
+{
+if ( iInfo.iActiveCamera == ECamActiveCameraSecondary )
+{
+PRINT( _L("Camera <> slide open -> switch to primary") );
+iCameraSwitchRequired = ESwitchSecondaryToPrimary;
+}
+else
+{
+PRINT( _L("Camera <> no camera switch needed") );
+iCameraSwitchRequired = ESwitchDone;
+}
+}
+else
+{
+// do nothing
+PRINT( _L("Camera <> not recognized slider state -> no action") );
+}
+}
+PRINT( _L("Camera <= CCamAppController::CheckSlideStatus") );
+}
+// ----------------------------------------------------
+// CCamAppController::EvRange
+// Range of EV value supported by current product
+// ----------------------------------------------------
+//
+TCamEvCompRange CCamAppController::EvRange() const
+{
+PRINT( _L("Camera =><= CCamAppController::EvRange") );
+return iEvRange;
+}
+// ----------------------------------------------------
+// CCamAppController::CallStateChanged
+// Callback for when the current phone call state changes
+// ----------------------------------------------------
+//
+void
+CCamAppController::CallStateChanged( TPSCTsyCallState aState,
+TInt                  /* aError */ )
+{
+PRINT1( _L("Camera => CCamAppController::CallStateChanged aState: %d"), aState);
+TBool oldState = iInCallOrRinging;
+if ( aState == EPSCTsyCallStateAlerting ||
+aState == EPSCTsyCallStateRinging ||
+aState == EPSCTsyCallStateDialling ||
+aState == EPSCTsyCallStateAnswering ||
+aState == EPSCTsyCallStateDisconnecting ||
+aState == EPSCTsyCallStateConnected ||
+aState == EPSCTsyCallStateHold )
+{
+// If not already in a call/ringing state, and the new state
+// indicates this, stop recording
+if ( !iInCallOrRinging )
+{
+// Set the flag before handle call, as this may need to
+// know the call state for stopping video.
+iInCallOrRinging = ETrue;
+PRINT( _L("Camera <> CCamAppController::CallStateChanged: calling handleincomingcallL") );
+HandleIncomingCall();
+}
+}
+else
+{
+iInCallOrRinging = EFalse;
+}
+// If the state has changed from in a call to not, notify the
+// observers
+// Also notify again if the state has reached connected so that
+// the observer can reconsider its actions now that connection is complete
+if ( iInCallOrRinging               != oldState ||
+EPSCTsyCallStateConnected == aState )
+{
+PRINT( _L("Camera <> CCamAppController::CallStateChanged: telling call observers") );
+NotifyControllerObservers( ECamEventCallStateChanged, KErrNone );
+}
+PRINT1( _L("Camera <= CCamAppController::CallStateChanged(%d, %d)"), aState );
+}
+// ---------------------------------------------------------------------------
+// ReleaseCamera
+//
+// Releases the camera hardware for other apps to use
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ReleaseCamera()
+{
+PRINT( _L("Camera => CCamAppController::ReleaseCamera") );
+if ( IsAppUiAvailable())
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi )
+{
+appUi->SetAssumePostCaptureView( EFalse );
+}
+}
+if ( Busy() )
+{
+PRINT( _L("Camera <> CCamAppController::ReleaseCamera: set release pending") );
+iPendingRelease = ETrue;
+}
+else if ( iCameraController && ECamCameraIdle != CameraState() )
+{
+// No leaving code here. Clear the flag before any operation
+// to prevent calling this from the event callbacks caused
+// by the following requests.
+iPendingRelease = EFalse;
+if( iInfo.iImageMode == ECamImageCaptureBurst &&
+SequenceCaptureInProgress() )
+{
+// Cancel ongoing burst capture
+// Burst capture is normally cancelled by setting iRequestedBurstCount,
+// and actual cancelling is done when next imagedata arrives.
+// However, in this case camera is going to be released, and there won't
+// be next image data, so give ECamRequestImageCancel and capture
+// completion event here to avoid problems
+PRINT( _L("Camera <> CCamAppController::ReleaseCamera: Going to bacgkround in the middle of a burst capture") );
+TRAP_IGNORE ( IssueDirectRequestL( ECamRequestImageCancel ) );
+NotifyControllerObservers( ECamEventCaptureComplete, KErrCancel );
+}
+//iInfo.iMode            = ECamControllerShutdown;
+//iInfo.iTargetMode      = ECamControllerIdle;
+iInfo.iTargetMode      = ECamControllerIdle;
+iInfo.iImageMode       = ECamImageCaptureNone;
+iInfo.iTargetImageMode = ECamImageCaptureNone;
+iInfo.iOperation       = ECamNoOperation;
+iCaptureModeTransitionInProgress = EFalse;
+// Last change to stop view finder if we were "busy" previously in
+// ExitViewfinderMode method. View finder must be stopped in case where
+// orientation is changed, so Posting API display control doesn't try to
+// draw outside existing area. Otherwise KErrTooBig error is encountered.
+StopViewFinder();
+PRINT( _L("Camera <> CCamAppController::ReleaseCamera: requesting release directly..") );
+// iInfo.iMode set when complete
+TRAP_IGNORE( IssueDirectRequestL( ECamRequestRelease ) );
+//iPendingRelease = EFalse;
+//shutdown the orientation channel
+if( iConfigManager && iConfigManager->IsOrientationSensorSupported() &&
+		iAccSensorListening )
+{
+TRAP_IGNORE( UpdateSensorApiL( EFalse ) );
+}
+}
+else
+{
+// No action needed.
+PRINT( _L("Camera <> CCamAppController::ReleaseCamera: camera already idle!!") );
+if(ECamControllerIdle != iInfo.iMode )
+{
+PRINT( _L("Camera <> CCamAppController::ReleaseCamera: camera already idle correcting state!!") );
+iInfo.iMode = ECamControllerIdle;
+}
+}
+PRINT( _L("Camera <= CCamAppController::ReleaseCamera") );
+}
+// ---------------------------------------------------------------------------
+// IncCameraUsers
+//
+// Increments the camera usage count
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::IncCameraUsers()
+{
+PRINT ( _L("Camera => CCamAppController::IncCameraUsers") );
+iCameraReferences++;
+PRINT1( _L("Camera <= CCamAppController::IncCameraUsers, count now %d"), iCameraReferences );
+}
+// ---------------------------------------------------------------------------
+// DecCameraUsers
+//
+// Decrements the camera usage count
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DecCameraUsers()
+{
+PRINT ( _L("Camera => CCamAppController::DecCameraUsers") );
+__ASSERT_DEBUG( iCameraReferences > 0, CamPanic( ECamPanicInvalidState ) );
+iCameraReferences--;
+PRINT1( _L("Camera <> CCamAppController::DecCameraUsers: count now %d"), iCameraReferences );
+// If the engine is no longer required then release it.
+if ( iCameraReferences <= 0 )
+{
+ReleaseCamera();
+}
+PRINT ( _L("Camera <= CCamAppController::DecCameraUsers") );
+}
+// ----------------------------------------------------
+// CCamAppController::InCallOrRinging
+// Whether we are in call or ringing
+// ----------------------------------------------------
+//
+TBool
+CCamAppController::InCallOrRinging() const
+{
+return iInCallOrRinging;
+}
+// ----------------------------------------------------
+// CCamAppController::InVideocallOrRinging
+// Whether we are in videocall or ringing
+// ----------------------------------------------------
+//
+TBool
+CCamAppController::InVideocallOrRinging()
+{
+if ( InCallOrRinging() )
+{
+TInt callType( EPSCTsyCallTypeUninitialized );
+TInt err = RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType );
+if ( err == KErrNone && callType == EPSCTsyCallTypeH324Multimedia )
+{
+return ETrue;
+}
+else
+{
+return EFalse;
+}
+}
+else
+{
+return EFalse;
+}
+}
+// ----------------------------------------------------
+// CCamAppController::CurrentlySavingVideo
+// Whether we are currently saving a video clip or not
+// ----------------------------------------------------
+//
+TBool
+CCamAppController::CurrentlySavingVideo() const
+{
+return iSaving;
+}
+// ---------------------------------------------------------------------------
+// IssueModeChangeSequenceL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::IssueModeChangeSequenceL( TBool aStartup )
+{
+PRINT( _L( "Camera => CCamAppController::IssueModeChangeSequenceL" ) );
+// Generate the request sequence and issue to Camera Controller.
+RCamRequestArray sequence;
+CleanupClosePushL( sequence );
+if( !aStartup )
+{
+GenerateModeChangeSequenceL( sequence );
+	if( iCameraReferences )
+{
+SetFlags( iBusyFlags, EBusySequence );
+TCleanupItem clearBusy( ClearSequenceBusyFlag, &iBusyFlags );
+CleanupStack::PushL( clearBusy );
+iCameraController->RequestSequenceL( sequence );
+CleanupStack::Pop();
+iCaptureModeTransitionInProgress = ETrue;
+}
+else
+	  {
+PRINT( _L("Camera <> No camera users, not requesting sequence.") );
+}
+}
+else
+{
+GenerateStartupSequenceL( sequence );
+	SetFlags( iBusyFlags, EBusySequence );
+TCleanupItem clearBusy( ClearSequenceBusyFlag, &iBusyFlags );
+CleanupStack::PushL( clearBusy );
+iCameraController->RequestSequenceL( sequence );
+CleanupStack::Pop();
+}
+CleanupStack::PopAndDestroy(); // sequence.Close()
+PRINT( _L( "Camera <= CCamAppController::IssueModeChangeSequenceL" ) );
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::GenerateModeChangeSequenceL( RCamRequestArray& aSequence )
+{
+PRINT( _L( "Camera => CCamAppController::GenerateModeChangeSequenceL" ) );
+TBool vfStartDone = EFalse;
+//Have to empty autofocusrequest values here because modechange could override
+//currently processed autofocus request.
+iPendingAFRequest=0;
+iCurrentAFRequest=0;
+iNoBurstCancel = EFalse;
+iKeyUP = EFalse;
+iAFCancelInProgress = EFalse;
+// -------------------------------------------------------
+if( ECamTriIdle != iCameraController->ViewfinderState() )
+{
+// If VF is not stopped, frames might come when we are not
+// in either image or video mode.
+if( ECamControllerIdle != iInfo.iMode
+&& iInfo.iTargetMode  != iInfo.iMode )
+{
+aSequence.Append( ECamRequestVfRelease );
+}
+else
+if( ECamTriIdle == iInfo.iTargetVfState )
+{
+aSequence.Append( ECamRequestVfRelease );
+}
+else if( ECamTriInactive == iInfo.iTargetVfState )
+{
+aSequence.Append( ECamRequestVfStop );
+}
+else
+{
+// Nothing needed here
+}
+}
+switch( iInfo.iMode )
+{
+// ---------------------------------
+case ECamControllerImage:
+{
+if( ECamControllerImage != iInfo.iTargetMode )
+{
+aSequence.Append( ECamRequestImageRelease );
+}
+break;
+}
+// ---------------------------------
+case ECamControllerVideo:
+{
+if( ECamControllerVideo != iInfo.iTargetMode )
+{
+aSequence.Append( ECamRequestVideoRelease );
+}
+break;
+}
+// ---------------------------------
+default:
+{
+// If we need to get to video or image mode
+// make sure camera has power on before further requests.
+if( ECamControllerImage == iInfo.iTargetMode
+|| ECamControllerVideo == iInfo.iTargetMode )
+{
+TUint cameraState( iCameraController->State() );
+if( !(ECamPowerOn&cameraState) )
+{
+if( !(ECamReserved&cameraState) )
+{
+aSequence.Append( ECamRequestReserve );
+}
+aSequence.Append( ECamRequestPowerOn );
+}
+}
+break;
+}
+// ---------------------------------
+}
+// -------------------------------------------------------
+// Append prepare operations to achieve target camera mode
+switch( iInfo.iTargetMode )
+{
+// ---------------------------------
+case ECamControllerImage:
+{
+if( ECamImageCaptureNone != iInfo.iTargetImageMode )
+{
+aSequence.Append( ECamRequestImageInit );
+// Snapshot may have to be released and restarted because the
+// snapshot size may change.
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( appUi )
+{
+if( appUi->ShowPostCaptureView() || iInfo.iTargetImageMode == ECamImageCaptureBurst )
+{
+// If vf needs to be (re)started.
+// Camera Controller checks from Setting Provider if
+// viewfinder mode (direct/bitmap) has changed, and
+// releases old type first if needed.
+if( ECamTriActive == iInfo.iTargetVfState )
+{
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: VF start needed" ) );
+aSequence.Append( ECamRequestVfStart );
+vfStartDone = ETrue;
+}
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: Snapshot on" ) );
+aSequence.Append( ECamRequestSsRelease );
+aSequence.Append( ECamRequestSsStart );
+}
+else
+{
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: Snapshot off" ) );
+aSequence.Append( ECamRequestSsRelease );
+aSequence.Append( ECamRequestSsStop );
+}
+}
+}
+break;
+}
+// ---------------------------------
+case ECamControllerVideo:
+{
+// Video recorder needs to be initialized and prepared
+// if we are not already in video mode.
+if ( iInfo.iMode != ECamControllerVideo )
+{
+iVideoInitNeeded = ETrue;
+}
+aSequence.Append( ECamRequestVideoInit );
+// Snapshot has to be released and restarted because the
+// snapshot size may change.
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( appUi )
+{
+if( appUi->ShowPostCaptureView() || iInfo.iTargetImageMode == ECamImageCaptureBurst )
+{
+// If vf needs to be (re)started.
+// Camera Controller checks from Setting Provider if
+// viewfinder mode (direct/bitmap) has changed, and
+// releases old type first if needed.
+if( ECamTriActive == iInfo.iTargetVfState )
+{
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: VF start needed" ) );
+aSequence.Append( ECamRequestVfStart );
+vfStartDone = ETrue;
+}
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: Snapshot on" ) );
+aSequence.Append( ECamRequestSsRelease );
+aSequence.Append( ECamRequestSsStart );
+}
+else
+{
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: Snapshot off" ) );
+aSequence.Append( ECamRequestSsRelease );
+aSequence.Append( ECamRequestSsStop );
+}
+}
+break;
+}
+// ---------------------------------
+default:
+break;
+// ---------------------------------
+}
+// If vf needs to be (re)started.
+// Camera Controller checks from Setting Provider if
+// viewfinder mode (direct/bitmap) has changed, and
+// releases old type first if needed.
+if( !vfStartDone && ECamTriActive == iInfo.iTargetVfState )
+{
+PRINT( _L( "Camera <> CCamAppController::GenerateModeChangeSequenceL: VF start needed" ) );
+aSequence.Append( ECamRequestVfStart );
+}
+// -------------------------------------------------------
+#ifdef _DEBUG
+PRINT( _L( "Camera <> Generated sequence: " ) );
+for( TInt i = 0; i < aSequence.Count(); i++ )
+{
+PRINT2( _L( "Camera <> %d) %s" ), i, KCamRequestNames[aSequence[i]] );
+}
+#endif
+PRINT( _L( "Camera <= CCamAppController::GenerateModeChangeSequenceL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SettingsPhotoResolution
+// Returns the photo resolution stored by the Settings Model
+// ---------------------------------------------------------------------------
+//
+TCamPhotoSizeId  CCamAppController::SettingsPhotoResolution() const
+{
+return iSettingsModel->CurrentPhotoResolution();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GetCurrentImageDimensions
+// ---------------------------------------------------------------------------
+//
+TSize
+CCamAppController::GetCurrentImageDimensions() const
+{
+TCamPhotoSizeId index = iSettingsModel->CurrentPhotoResolution();
+TSize           size  = iSettingsModel->ImageResolutionFromIndex( index );
+return size;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GetCurrentImageResolution
+// Gets the current image resolution used.  May not be the same at that stored in Settings
+// if Zoom state is not 1x
+// ---------------------------------------------------------------------------
+//
+TCamPhotoSizeId CCamAppController::GetCurrentImageResolution() const
+{
+TCamPhotoSizeId size = iSettingsModel->CurrentPhotoResolution();
+return size;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GetCurrentImageCompression
+// Returns the photo compression level from the Settings Model
+// ---------------------------------------------------------------------------
+//
+TInt  CCamAppController::GetCurrentImageCompression() const
+{
+return iSettingsModel->CurrentPhotoCompression();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GetCurrentVideoResolution
+// Gets the current video resolution used.
+// ---------------------------------------------------------------------------
+//
+TCamVideoResolution CCamAppController::GetCurrentVideoResolution() const
+{
+TInt videoQuality = iSettingsModel->IntegerSettingValue( ECamSettingItemVideoQuality );
+CCamVideoQualityLevel& level = *( iSettingsModel->VideoQualityArray() )[videoQuality];
+return static_cast<TCamVideoResolution>( level.VideoResolution() );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::UsePhoneMemoryL
+// Force use of phone memory storage.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::UsePhoneMemoryL() const
+{
+#ifdef PRODUCT_SUPPORTS_FORCE_MEDIA_STORAGE_VALUE
+// This function is used to directly force the value of media storage
+// Bypasses any updates the controller does for change to these values
+if( ExistMassStorage() )
+{
+iSettingsModel->SetIntegerSettingValueL( ECamSettingItemPhotoMediaStorage,
+ECamMediaStorageMassStorage );
+iSettingsModel->SetIntegerSettingValueL( ECamSettingItemVideoMediaStorage,
+ECamMediaStorageMassStorage );
+}
+else
+{
+iSettingsModel->SetIntegerSettingValueL( ECamSettingItemPhotoMediaStorage,
+ECamMediaStoragePhone );
+iSettingsModel->SetIntegerSettingValueL( ECamSettingItemVideoMediaStorage,
+ECamMediaStoragePhone );
+}
+#endif // PRODUCT_SUPPORTS_FORCE_MEDIA_STORAGE_VALUE
+}
+// ===========================================================================
+// From MCamSettingsModelObserver
+// ---------------------------------------------------------------------------
+// CCamAppController::IntSettingChangedL
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::IntSettingChangedL( TCamSettingItemIds aSettingItem,
+TInt               aSettingValue )
+{
+switch( aSettingItem )
+{
+case ECamSettingItemDynamicSelfTimer:
+{
+TCamSelfTimerFunctions function( ECamSelfTimerDisabled );
+switch( aSettingValue )
+{
+case ECamSelfTimer2:  function = ECamSelfTimerMode1; break;
+case ECamSelfTimer10: function = ECamSelfTimerMode2; break;
+case ECamSelfTimer20: function = ECamSelfTimerMode3; break;
+default:                                             break;
+}
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( appUi )
+{
+appUi->SelfTimerEnableL( function );
+}
+break;
+}
+case ECamSettingItemPhotoQuality:
+{
+HandleImageQualitySettingChangeL();
+break;
+}
+case ECamSettingItemVideoQuality:
+NotifyControllerObservers( ECamEventVideoQualityChanged, KErrNone );
+break;
+case ECamSettingItemVideoAudioRec:
+{
+NotifyControllerObservers( ECamEventAudioMuteStateChanged );
+break;
+}
+case ECamSettingItemContinuousAutofocus:
+{
+NotifyControllerObservers( ECamEventContAFStateChanged );
+break;
+}
+case ECamSettingItemFaceTracking:
+{
+PRINT( _L("Camera => ECamSettingItemFaceTracking") );
+TCamCameraSettingId cameraId(
+CCamSettingConversion::Map2CameraControllerSettingId( aSettingItem ) );
+iCameraController->DirectSettingsChangeL( cameraId );
+NotifyControllerObservers( ECamEventFaceTrackingStateChanged );
+break;
+}
+case ECamSettingItemDynamicVideoFlash:
+{
+PRINT( _L("Camera => ECamSettingItemDynamicVideoFlash") );
+TCamCameraSettingId cameraId(
+CCamSettingConversion::Map2CameraControllerSettingId( aSettingItem ) );
+iCameraController->DirectSettingsChangeL( cameraId );
+break;
+}
+default:
+{
+break;
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TextSettingChangedL
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::TextSettingChangedL( TCamSettingItemIds /*aSettingItem*/,
+const TDesC&       /*aSettingValue*/ )
+{
+}
+// ---------------------------------------------------------------------------
+// HandleImageQualitySettingChangeL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleImageQualitySettingChangeL()
+{
+PRINT( _L("Camera => CCamAppController::HandleImageQualitySettingChangeL") );
+if( IsViewFinding() )
+{
+PRINT( _L("Camera <> CCamAppController - viewfinder on, stop vf / re-prepare / start vf..") );
+TRAPD( status,
+{
+IssueDirectRequestL( ECamRequestVfStop    );
+IssueDirectRequestL( ECamRequestSsRelease );
+IssueDirectRequestL( ECamRequestImageInit );
+IssueDirectRequestL( ECamRequestSsStart   );
+IssueDirectRequestL( ECamRequestVfStart   );
+});
+if( KErrNone != status )
+{
+SetOperation( ECamStandby, status );
+}
+}
+NotifyControllerObservers( ECamEventImageQualityChanged, KErrNone );
+PRINT( _L("Camera <= CCamAppController::HandleImageQualitySettingChangeL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::BurstModeActive
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::BurstModeActiveL( TBool aActive, TBool /*aStillModeActive*/ )
+{
+PRINT1( _L("Camera => CCamAppController::BurstModeActiveL %d"), aActive );
+if( ECamControllerImage == iInfo.iMode )
+{
+//TCamImageCaptureMode oldImageMode = iInfo.iImageMode;
+// We are in still capture mode
+if( aActive )
+{
+PRINT( _L("Camera <> CCamAppController .. iInfo.iImageMode = appUi->CurrentBurstMode() ") );
+// Burst mode active. Query current mode from AppUi
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// iInfo.iImageMode = appUi->CurrentBurstMode();
+SetImageMode( appUi->CurrentBurstMode() );
+// reset image orientation
+iImageOrientation = ECamOrientation0;
+TRAP_IGNORE( SetImageOrientationL() );
+}
+else
+{
+// Burst mode not active
+PRINT( _L("Camera <> CCamAppController .. iInfo.iImageMode = ECamImageCaptureSingle ") );
+// iInfo.iImageMode = ECamImageCaptureSingle;
+SetImageMode( ECamImageCaptureSingle );
+}
+iRequestedCaptureCount = ( ECamImageCaptureBurst == iInfo.iImageMode )
+? KShortBurstCount
+: 1;
+iCameraController->DirectSettingsChangeL( ECameraSettingCaptureLimit );
+// set image orientation in case it was changed during burst mode
+if( iOrientationChangeOccured )
+{
+iOrientationChangeOccured = EFalse;
+TRAP_IGNORE( SetImageOrientationL() );
+}
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController .. [WARNING] Not in image mode, set iInfo.iImageMode = ECamImageCaptureNone") );
+// iInfo.iImageMode = ECamImageCaptureNone;
+SetImageMode( ECamImageCaptureNone );
+}
+PRINT( _L("Camera <= CCamAppController::BurstModeActiveL %d") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetVideoLengthL
+// Set video length (max or short)
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetVideoLengthL( TInt /*aLength*/ )
+{
+PRINT( _L( "Camera => CCamAppController::SetVideoLengthL" ) );
+User::Leave( KErrNotSupported );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentPhotoStorageLocation
+// Returns the current photo storage location filtered by MMC presence
+// ---------------------------------------------------------------------------
+TInt CCamAppController::CurrentPhotoStorageLocation() const
+{
+TInt storageLocation = iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoMediaStorage );
+// added iForceUseOfPhoneMemory part to treat current location
+// as Mass Storage / Phone, also if it is forced.
+if (  iForceUseOfPhoneMemory ||
+( ( storageLocation == ECamMediaStorageCard ) &&
+( CamUtility::MemoryCardStatus() != ECamMemoryCardInserted ) ) )
+{
+if ( ExistMassStorage() )
+{
+storageLocation = ECamMediaStorageMassStorage;
+}
+else
+{
+storageLocation = ECamMediaStoragePhone;
+}
+}
+return storageLocation;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentVideoStorageLocation
+// Returns the current video storage location filtered by MMC presence
+// ---------------------------------------------------------------------------
+TInt CCamAppController::CurrentVideoStorageLocation() const
+	{
+	TInt storageLocation = iSettingsModel->IntegerSettingValue( ECamSettingItemVideoMediaStorage );
+	// added iForceUseOfPhoneMemory part to treat current location
+	// as Mass Storage / Phone, also if it is forced.
+if ( iForceUseOfPhoneMemory )
+{
+storageLocation = iForcedStorageLocation;
+}
+return storageLocation;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ReleaseArray
+// Record that the view has finished with the array
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ReleaseArray( TBool aForcedRelease )
+{
+PRINT( _L("Camera => CCamAppController::ReleaseArray") );
+// Otherwise  we were using the real capture array, so reset it
+if( iArrayUsageCount > 0 )
+{
+iArrayUsageCount--;
+}
+if ( iArrayUsageCount == 0 || aForcedRelease )
+{
+PRINT( _L("Camere <> CCamAppController::ReleaseArray .. usage to 0") );
+iCaptureArray->Reset();
+iCurrentImageIndex = 0;
+// May have released a large amount of memory, so compress the heap
+User::Heap().Compress();
+}
+PRINT( _L("Camera <= CCamAppController::ReleaseArray") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RestoreFactorySettingsL
+// Delete
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::RestoreFactorySettingsL( TBool aIsEmbedded )
+{
+PRINT( _L("Camera => CCamAppController::RestoreFactorySettingsL") );
+iSettingsModel->ResetRepository();
+// reload static settings
+LoadStaticSettingsL( aIsEmbedded );
+// reload dynamic settings
+SetDynamicSettingsToDefaults();
+// Restoring camera settings didn't set the capture mode to single capture,
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+appUi->SwitchStillCaptureModeL( ECamImageCaptureSingle, EFalse, EFalse );
+//
+SetMode( ECamControllerIdle );
+if( iLocationTrailStarted &&
+ECamLocationOn != IntegerSettingValue( ECamSettingItemRecLocation ) )
+{
+PRINT( _L("Camera <> CCamAppController::RestoreFactorySettingsL - Stop location trail") );
+// Location trail has been started, but setting off after restore -> stop trail
+// Starting (if needed after restore) happens when still precap view is activated
+StopLocationTrail();
+}
+//
+NotifyControllerObservers( ECamEventRestoreCameraSettings );
+PRINT( _L("Camera <= CCamAppController::RestoreFactorySettingsL") );
+}
+// ---------------------------------------------------------------------------
+// PlayComplete
+//
+// Called from when sound playing completes.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::PlayComplete( TInt /*aStatus*/, TInt /*aSoundId*/ )
+{
+PlaySoundComplete();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PlaySoundComplete
+// Called when playback of a sound has completed.  Typically used in conjunction
+// with Video recording (must only start recording AFTER sound has finished
+// to avoid recording the sound in the recorded clip).
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::PlaySoundComplete()
+{
+PRINT( _L("Camera => CCamAppController::PlaySoundComplete") );
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_PLAYSOUNDCOMPLETE, "e_CAM_APP_CAPTURE_SOUND_PLAY 0" );    //CCORAPP_CAPTURE_SOUND_PLAY_END
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicInvalidState ) );
+if( ECamControllerVideo == iInfo.iMode && !IsKeyLockOn() )
+{
+switch( CurrentVideoOperation() )
+{
+case ECamResuming:
+{
+// Restarting video
+DoRecord();
+break;
+}
+case ECamPausing:
+{
+// Notifies observers, so paused icon and softkeys can be updated.
+SetOperation( ECamPaused );
+break;
+}
+case ECamNoOperation:
+{
+// Starting the video capture
+// If the next file path has not changed, start capturing
+if ( BurstCaptureArray()->FileName( 0 ).Compare( iSuggestedVideoPath ) == 0 )
+{
+PRINT( _L("Camera <> starting to record..") );
+DoRecord();
+}
+// File path changed. Prepare the engine with the new video file path.
+// Start video recording when filename changed (event)
+else
+{
+iVideoRequested = ETrue;
+iSuggestedVideoPath.Copy( BurstCaptureArray()->FileName( 0 ) );
+PRINT1( _L("Camera <> Requesting Camera controller to set the video name, iSuggestedVideoPath = [%S] "), &iSuggestedVideoPath );
+TRAP_IGNORE(
+{
+// Set video name change pending and request setting it to camera controller.
+iSettingProvider->AddPendingSettingChangeL( ECamSettingItemVideoNameBase );
+IssueSettingsChangeRequestL();
+});
+iVideoNameRetries = KVideoNameRetryCount;
+}
+}
+default:
+{
+// No operation.
+// Should be stopping video
+}
+}
+}
+else
+{
+// Image mode or keylock on, no action
+}
+PRINT( _L("Camera <= CCamAppController::PlaySoundComplete") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::MediaFileChangedNotification
+//Helper function for making notification about deleted files
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::MediaFileChangedNotification()
+{
+PRINT( _L("Camera => CCamAppController::MediaFileChangedNotification") );
+NotifyControllerObservers( ECamEventMediaFileChanged );
+PRINT( _L("Camera <= CCamAppController::MediaFileChangedNotification") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DeleteCurrentFile
+// Delete the current image/video file
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::DeleteCurrentFile( TBool aNotify /*=ETrue*/ )
+{
+PRINT( _L("Camera => CCamAppController::DeleteCurrentFile") );
+iImageSaveRequestPending = EFalse;
+TInt err( KErrNone );
+if( BurstCaptureArray()->Count() > 0 )
+{
+err = BurstCaptureArray()->SetDeleted( iCurrentImageIndex, ETrue );
+if ( aNotify && err == KErrNone )
+{
+NotifyControllerObservers( ECamEventMediaFileChanged );
+}
+}
+PRINT( _L("Camera <= CCamAppController::DeleteCurrentFile") );
+return err;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DeleteTimeLapseFiles
+// Delete the current timelapse sequence
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::DeleteTimeLapseFiles()
+{
+// Count() is inline
+for ( TInt i = 0; i < iSequenceFilenameArray->Count(); i++ )
+{
+TPtrC filename( iSequenceFilenameArray->MdcaPoint( i ) );
+// Error ignored
+(void)iImageSaveActive->DeleteFile( filename, ETrue );
+}
+iSequenceFilenameArray->Reset();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsProcessingCapture
+// Indicate whether or not the controller is actively engaged in still
+// or video capture
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsProcessingCapture()
+{
+return ( iCaptureRequested  // if a still capture is pending
+|| iVideoRequested    // if a video capture is pending
+|| EngineProcessingCapture() // if recording or capture is active
+|| ECamImageCaptureTimeLapse == iInfo.iImageMode  // if capturing time lapse
+|| CurrentlySavingVideo() );        // if a video save is in progress
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CompleteCaptureAndNotifyL
+// Request that any current processes complete, then notify observers
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::CompleteCaptureAndNotifyL( MCamObserver* aObserver,
+TBool         aSafeCompletion )
+{
+PRINT( _L( "Camera => CCamAppController::CompleteCaptureAndNotifyL" ) )
+RProperty::Set( KPSUidCamcorderNotifier, KCCorFocused, 0 );
+// Add the observer to the observer handler for capture completion.
+if ( !iCaptureCompletionObserverHandler )
+{
+iCaptureCompletionObserverHandler = CCamObserverHandler::NewL();
+}
+iCaptureCompletionObserverHandler->RegisterObserverL( aObserver );
+// if the capture has not yet begun, all that is required is to switch off
+// the pending capture
+iCaptureRequested = EFalse;
+iVideoRequested   = EFalse;
+// if no capture is actively in progress
+if ( !IsProcessingCapture() )
+{
+PRINT( _L( "Camera <> not capturing calling HandleCaptureCompletion" ) )
+HandleCaptureCompletion();
+}
+// if recording is active
+else if ( ECamControllerVideo == iInfo.iMode )
+{
+if( ECamCapturing == iInfo.iOperation
+|| ECamPausing   == iInfo.iOperation
+|| ECamPaused    == iInfo.iOperation
+|| ECamResuming  == iInfo.iOperation )
+{
+PRINT( _L( "Camera <> currently recording calling StopVideoRecording()" ) )
+StopVideoRecording();
+// iCaptureCompletionObserverHandler will be notified when the record completes
+// in McaeoVideoRecordingComplete
+}
+}
+else if ( ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+PRINT( _L( "Camera <> Calling StopSequenceCapture" ) )
+StopSequenceCaptureL();
+// iCaptureCompletionObserverHandler will be notified when the
+// next image saving completes
+}
+// if a burst capture is in early stages
+else if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+if( ECamCapturing == iInfo.iOperation )
+{
+if ( !aSafeCompletion )
+{
+//iEngine->CancelCaptureStill();
+PRINT( _L( "Camera <> Safe completion requested, currently capturing burst, issue ECamRequestImageCancel" ) )
+IssueDirectRequestL( ECamRequestImageCancel );
+CompleteBurstOperation();
+}
+else
+{
+//iEngine->StopStillBurstCapture();
+PRINT( _L( "Camera <> Not safe completion requested, currently capturing burst, issue ECamRequestImageCancel" ) )
+IssueDirectRequestL( ECamRequestImageCancel );
+// iCaptureCompletionObserverHandler will be notified when the
+// image saving completes
+}
+}
+}
+else // do nothing
+{
+PRINT( _L( "Camera <> currently waiting for capture completion" ) )
+// e.g. iOperation == ECamCaptureCompleting
+// iCaptureCompletionObserverHandler will be notified when the
+// image saving completes
+// e.g. CurrentlySavingVideo()
+// iCaptureCompletionObserverHandler will be notified when the
+// video saving completes in McaeoVideoRecordingComplete
+// e.g. iOperation == ECamCaptureInProgress (single capture)
+// iCaptureCompletionObserverHandler will be notified when the
+// image saving completes
+}
+PRINT( _L( "Camera <= CCamAppController::CompleteCaptureAndNotifyL" ) )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::EnterShutdownMode
+// Enter shutdown mode as the application is closing
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::EnterShutdownMode( TBool aImmediateShutdown )
+{
+PRINT1( _L( "Camera => CCamAppController::EnterShutdownMode( aImmediateShutdown=%d )"), aImmediateShutdown );
+DeRegisterHarverterClientEvents();
+if ( !IsInShutdownMode() )
+{
+PRINT ( _L( "Camera <> CCamAppController::EnterShutdownMode: set target mode to ECamControllerShutdown..") );
+SetTargetMode( ECamControllerShutdown );
+}
+// if not close down straightaway (i.e. for embedded )
+if ( !aImmediateShutdown )
+{
+// cancel any outstanding sound requests
+// iSoundPlayer->CancelTonePlayer();
+iSoundPlayer->CancelAllPlaying();
+TRAPD( err, CompleteCaptureAndNotifyL( this, EFalse ) )
+if ( err )
+{
+NotifyControllerObservers( ECamEventExitRequested, KErrNone );
+}
+}
+else
+{
+// This checks for any ongoing operation.
+ReleaseCamera();
+}
+PRINT ( _L( "Camera <= CCamAppController::EnterShutdownMode") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsInShutdownMode
+// Whether or not the controller is in shutdown mode
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsInShutdownMode() const
+{
+return ( ECamControllerShutdown == iInfo.iTargetMode );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsAppUiAvailable
+// Returns true if AppUi has been constructed, and not yet destructed
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsAppUiAvailable() const
+{
+return iAppUiAvailable;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetAppUiAvailable
+// Sets AppUi availablility (see IsAppUiAvailable)
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetAppUiAvailable( TBool aAvailable )
+{
+iAppUiAvailable = aAvailable;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GetZoomRange
+// Returns the minimum and maximum supported zoom values
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::GetZoomRange( TInt& aMinZoom, TInt& aMaxZoom ) const
+{
+__ASSERT_ALWAYS( iCameraController, CamPanic( ECamPanicNullPointer ) );
+aMinZoom = 0;
+aMaxZoom = iCameraController->CameraInfo().iMaxDigitalZoom;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ZoomValue
+// Returns the current zoom value
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::ZoomValue() const
+{
+return iDesiredZoomVal;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetZoomValue
+// Sets a new zoom value
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetZoomValue( TInt aValue )
+{
+PRINT1( _L("Camera => CCamAppController::SetZoomValue( %d )"), aValue );
+__ASSERT_ALWAYS( iCameraController, CamPanic( ECamPanicNullPointer ) );
+// Check the requested value for validity
+__ASSERT_DEBUG( Rng( 0, aValue, iCameraController->CameraInfo().iMaxDigitalZoom ),
+CamPanic( ECamPanicInvalidZoomValue ) );
+if ( ECamControllerImage == iInfo.iMode
+|| ECamControllerVideo == iInfo.iMode )
+{
+// Setting provider asks for the zoom value from us
+iDesiredZoomVal = aValue;
+if ( !iZoomWaitingForCamera )
+{
+PRINT( _L("Camera <> CCamAppController: calling Camera Controller..") );
+TRAPD( error,
+{
+iCameraController->DirectSettingsChangeL( ECameraSettingDigitalZoom );
+});
+// If no leave occurred, notification is done in HandleSettingEventL
+if( KErrNone != error )
+{
+NotifyControllerObservers( ECamEventZoomStateChanged, error );
+}
+// iZoomWaitingForCamera is set to EFalse when vf frame arrives.
+// With direct vf, this never happens, so do not set to ETrue.
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi && !appUi->IsDirectViewfinderActive() )
+{
+iZoomWaitingForCamera = ETrue;
+}
+iNewZoomPending = EFalse;
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController: zoom is waiting for VF update") );
+iNewZoomPending = ETrue;
+}
+}
+PRINT( _L("Camera <= CCamAppController::SetZoomValue") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ResetUserSceneL
+// Resets all the user scene settings to their defaults.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ResetUserSceneL()
+{
+iSettingsModel->ResetUserSceneL();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PreviewSettingChangeL
+//
+// Previews a new value for the specified integer setting.
+// If method leaves, preview is not activated.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::PreviewSettingChangeL( TInt aSettingItem,
+TInt aSettingValue )
+{
+PRINT( _L("Camera => CCamAppController::PreviewSettingChangeL") );
+__ASSERT_DEBUG( iSettingsPreviewHandler, CamPanic( ECamPanicNullPointer ) );
+TCamSettingItemIds settingId(
+static_cast<TCamSettingItemIds>(aSettingItem) );
+PRINT1( _L("Camera <> Setting to be previewed [%s]"), KCamSettingItemNames[settingId] );
+if ( settingId == ECamSettingItemDynamicSelfTimer )
+{
+SetSlideInSelfTimerPreview(ETrue);
+}
+// Activate the preview as a first thing.
+// If requests are issued to Camera Controller,
+// it asks for the setting value through Setting Provider and
+// the setting needs to be already in preview at that point.
+// If this fails, there's nothing we need to roll back.
+iSettingsPreviewHandler->ActivatePreviewL( settingId, aSettingValue );
+// Check which setting is previewed.
+// Some need special attention, or should/need not be set to Camera at this point.
+TInt status( KErrNone );
+switch( settingId )
+{
+// ---------------------------------
+// Image quality
+case ECamSettingItemPhotoQuality:
+// Still image quality does not require re-prepare,
+// as even the remining images counting is done
+// based on local size esimates.
+// Need to do notification to update counters.
+NotifyControllerObservers( ECamEventImageQualityChanged );
+break;
+// ---------------------------------
+// Video quality
+case ECamSettingItemVideoQuality:
+// Video needs to be re-prepared to be able to update
+// remaining time counters.
+NotifyControllerObservers( ECamEventVideoQualityChanged );
+break;
+// ---------------------------------
+// Self timer
+case ECamSettingItemDynamicSelfTimer:
+// Just set the preview. Once committed, set via AppUi.
+break;
+// ---------------------------------
+// Others - set to Camera to see the effect.
+default:
+{
+TCamCameraSettingId cameraId(
+CCamSettingConversion::Map2CameraControllerSettingId( settingId ) );
+//PRINT1( _L("Camera <> CCamAppController: Setting the preview to Camera, id[%s]"), KCameraSettingNames[settingId] );
+// Assertation to notice if some setting is not properly handled.
+__ASSERT_DEBUG( ECameraSettingNone != cameraId, CamPanic( ECamPanicNotSupported ) );
+if( ECameraSettingNone != cameraId )
+{
+// Preview is active.
+// Camera controller will ask the value during DirectSettingsChangeL.
+// Need trap to be able to cancel on failure.
+TRAP( status, iCameraController->DirectSettingsChangeL( cameraId ) );
+}
+break;
+}
+// ---------------------------------
+}
+if( KErrNone != status )
+{
+PRINT( _L("Camera <> CCamAppController: Problem in preview, cancelling!!!") );
+// Invalid id does not cause problem here.
+iSettingsPreviewHandler->CancelPreview( settingId );
+User::Leave( status );
+}
+PRINT( _L("Camera <= CCamAppController::PreviewSettingChangeL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CancelPreviewChangesL
+// Cancels all preview changes, since last commit/cancel.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::CancelPreviewChangesL()
+{
+PRINT( _L("Camera => CCamAppController::CancelPreviewChangesL") );
+// Just check non-null, but no panic.
+if ( iSettingsPreviewHandler )
+{
+RArray<TCamSettingItemIds> previews;
+CleanupClosePushL( previews );
+// Get all active previews
+iSettingsPreviewHandler->ActivePreviewsL( previews );
+// Reset all previews so the Setting Provider does
+// not get those values anymore.
+iSettingsPreviewHandler->CancelAllPreviews();
+// Reset the original setting values to Camera
+TInt                errorOne( KErrNone           );
+TInt                errorAll( KErrNone           );
+TCamCameraSettingId cameraId( ECameraSettingNone );
+for( TInt i = previews.Count() - 1; i >= 0; i-- )
+{
+if( ECamSettingItemVideoQuality == previews[i] )
+{
+TRAP( errorOne, RePrepareVideoL() );
+}
+else
+{
+cameraId =
+CCamSettingConversion::Map2CameraControllerSettingId( previews[i] );
+if( ECameraSettingNone != cameraId )
+{
+TRAP( errorOne, iCameraController->DirectSettingsChangeL( cameraId ) );
+}
+/* All previews are not set to Camera.
+else
+{
+errorOne = KErrNotSupported;
+}
+*/
+}
+if( KErrNone == errorAll
+&& KErrNone != errorOne )
+{
+errorAll = errorOne;
+}
+}
+User::LeaveIfError( errorAll );
+CleanupStack::PopAndDestroy(); // previews
+}
+PRINT( _L("Camera <= CCamAppController::CancelPreviewChangesL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CommitPreviewChanges
+// Commits last preview change.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::CommitPreviewChanges()
+{
+PRINT( _L("Camera => CCamAppController::CommitPreviewChanges") );
+__ASSERT_DEBUG( iSettingsPreviewHandler, CamPanic( ECamPanicNullPointer ) );
+// All previews have been set to Camera already.
+// Only need to request the model to store new values.
+// Currently ignore error, if settings model cannot save the preview.
+TRAPD( error, iSettingsPreviewHandler->CommitAllPreviewsL() );
+if( KErrNone != error )
+{
+// Ignored.
+PRINT( _L("Camera <> Settings model could not save the preview!!!") );
+}
+PRINT( _L("Camera <= CCamAppController::CommitPreviewChanges") );
+}
+// ---------------------------------------------------------------------------
+// RePrepareVideoL
+//
+// Helper method for re-preparing video if e.g. a setting change
+// requires it. If Camera Controller is currently processing
+// some request, set the flag to issue the request later.
+//
+// Used atleast in PreviewSettingChangeL and CancelPreviewChangesL.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::RePrepareVideoL()
+{
+PRINT( _L("Camera => CCamAppController::RePrepareVideoL") );
+GenerateNextValidVideoPathL();
+if( !Busy() )
+{
+iVideoPrepareNeeded = EFalse;
+IssueRequestL( ECamRequestVideoInit );
+}
+else
+{
+iVideoPrepareNeeded = ETrue;
+}
+PRINT( _L("Camera <= CCamAppController::RePrepareVideoL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IntegerSettingValue
+// Returns the current integer value for the specified setting
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::IntegerSettingValue( TInt aSettingItem ) const
+{
+// If the requested item is the photo storage location, this must be filtered
+// based on the availability of the MMC.
+if ( aSettingItem == ECamSettingItemPhotoMediaStorage )
+{
+return CurrentPhotoStorageLocation();
+}
+// If the requested item is the video storage location, this must be filtered
+// based on the availability of the MMC.
+if ( aSettingItem == ECamSettingItemVideoMediaStorage )
+{
+return CurrentVideoStorageLocation();
+}
+// Not a setting we sometimes need to filter
+return IntegerSettingValueUnfiltered( aSettingItem );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IntegerSettingValueUnfiltered
+// Returns the current integer value for the specified setting
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::IntegerSettingValueUnfiltered( TInt aSettingItem ) const
+{
+if( aSettingItem == ECamSettingItemVideoFileType )
+{
+TInt videoQuality = iSettingsModel->IntegerSettingValue( ECamSettingItemVideoQuality );
+CCamVideoQualityLevel& level = *( iSettingsModel->VideoQualityArray() )[videoQuality];
+return level.VideoType();
+}
+// Query the relevant settings model.
+return iSettingsModel->IntegerSettingValue( aSettingItem );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetIntegerSettingValueL
+// Sets a new value for the specified integer setting
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetIntegerSettingValueL( TInt aSettingItem,
+TInt aSettingValue )
+{
+PRINT( _L("Camera => CCamAppController::SetIntegerSettingValueL"))
+// Update the settings model.
+iSettingsModel->SetIntegerSettingValueL( aSettingItem, aSettingValue );
+// Update observers with any changes that do not directly affect the
+// engine. That is, they need to be updated now because the settings model
+// will not pass these to this observer.
+switch( aSettingItem )
+{
+case ECamSettingItemPhotoMediaStorage:
+case ECamSettingItemVideoMediaStorage:
+{
+PRINT(_L("Camera SetIntegerSettingValueL calling SetPathnamesToNewStorageL" ))
+// reset iForceUseOfPhoneMemory flag when user chooses
+// from settings.
+iForceUseOfPhoneMemory = EFalse;
+SetPathnamesToNewStorageL(static_cast < TCamMediaStorage > ( aSettingValue ) );
+InitCaptureLimitL();
+break;
+}
+case ECamSettingItemDynamicVideoScene:
+{
+iVideoInitNeeded = ETrue;
+NotifyControllerObservers( ECamEventSceneStateChanged );
+break;
+}
+case ECamSettingItemDynamicPhotoScene:
+case ECamSettingItemUserSceneBasedOnScene:
+{
+if( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+// Check for macro or landscape scene/based on scene and
+// set up AF accordingly. For other scenes, the AF mode
+// is setup at capture
+CheckAfModeForScene();
+}
+NotifyControllerObservers( ECamEventSceneStateChanged );
+break;
+}
+case ECamSettingItemVideoAudioRec:
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi->IsEmbedded() )
+{
+iCameraController->DirectSettingsChangeL( ECameraSettingAudioMute );
+}
+NotifyControllerObservers( ECamEventAudioMuteStateChanged );
+break;
+}
+case ECamSettingItemContinuousAutofocus:
+{
+iSettingProvider->AddPendingSettingChangeL( ECamSettingItemContinuousAutofocus );
+IssueSettingsChangeRequestL();
+break;
+}
+case ECamSettingItemPhotoStoreInAlbum:
+case ECamSettingItemVideoStoreInAlbum:
+{
+TUint32 defaultAlbumId = static_cast<TUint32>(
+IntegerSettingValue( ECamSettingItemDefaultAlbumId ));
+iImageSaveActive->SetAddImageToAlbum( aSettingValue == ECamSettYes,
+defaultAlbumId );
+break;
+}
+case ECamSettingItemRecLocation:
+{
+// Set the location utility active object
+if ( ECamLocationOff == aSettingValue )
+{
+StopLocationTrail();
+}
+else if ( ECamLocationOn == aSettingValue )
+{
+StartLocationTrailL();
+}
+// Notify observers
+NotifyControllerObservers( ECamEventLocationSettingChanged );
+break;
+}
+// Need to support more zoom settings.
+// Digital/extended setting combined to
+// ECamSettingItemPhotoDigitalZoom and ECamSettingItemVideoDigitalZoom
+case ECamSettingItemPhotoDigitalZoom:
+case ECamSettingItemVideoDigitalZoom:
+{
+// Notify observers
+NotifyControllerObservers( ECamEventZoomSetupChanged );
+break;
+}
+default:
+{
+// no action for others here
+break;
+}
+}
+PRINT( _L("Camera <= CCamAppController::SetIntegerSettingValueL"))
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetPathnamesToNewStorageL
+// Sets pathnames for video and image files to point to new storage
+// ---------------------------------------------------------------------------
+void CCamAppController::SetPathnamesToNewStorageL( TCamMediaStorage aMediaStorage )
+{
+PRINT(_L("Camera => CCamAppController::SetPathnamesToNewStorageL" ))
+iSetNewPathnamesPending = ECamMediaStorageNone;
+TFileName path;
+// If the engine is prepared for image capture then check that the required
+// image folder exists
+if ( IsFlagOn( CameraControllerState(), ECamImageOn ) )
+{
+CCamFolderUtility::GetBasePathL( iMonthFolderCounters,
+aMediaStorage,
+path,
+ECamControllerImage,
+EFalse );
+iCurrentStorage = aMediaStorage;
+}
+// If the engine is prepared for video capture then check that the required
+// month folder exists and set up the engine with the new video path, this
+// will be adjusted with the appropriate month counter folder when video
+// capture begins
+else if ( IsFlagOn( CameraControllerState(), ECamVideoOn ) )
+{
+CCamFolderUtility::GetBasePathL( iMonthFolderCounters,
+aMediaStorage,
+path,
+ECamControllerVideo,
+EFalse );
+if( iInfo.iOperation != ECamCapturing    &&
+iInfo.iOperation != ECamPausing      &&
+iInfo.iOperation != ECamPaused       &&
+iInfo.iOperation != ECamResuming   &&
+iInfo.iOperation != ECamCompleting )
+{
+GenerateNextValidVideoPathL();
+}
+iCurrentStorage = aMediaStorage;
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( !appUi->SettingsLaunchedFromCamera() )
+{
+// Set video name change pending and request setting it to camera controller.
+if( iInfo.iOperation != ECamCapturing    &&
+iInfo.iOperation != ECamPausing      &&
+iInfo.iOperation != ECamPaused       &&
+iInfo.iOperation != ECamResuming   &&
+iInfo.iOperation != ECamCompleting )
+	{
+iSettingProvider->AddPendingSettingChangeL( ECamSettingItemVideoNameBase );
+// Can't set the new pathname, if camera controller is busy.
+if ( CameraControllerBusy() )
+{
+PRINT( _L("Camera <> Camera controller busy. New pathname not set. Set iSetNewPathnamesPending.") )
+iSetNewPathnamesPending = aMediaStorage;
+}
+else
+{
+IssueSettingsChangeRequestL();
+}
+	}
+iVideoNameRetries   = KVideoNameRetryCount;
+//iVideoTimeRemaining = KMaxRecordingLength;
+if( iInfo.iOperation == ECamCapturing    ||
+iInfo.iOperation == ECamPausing      ||
+iInfo.iOperation == ECamPaused       ||
+iInfo.iOperation == ECamResuming     ||
+iInfo.iOperation == ECamCompleting )
+{
+iVideoTimeRemaining = iCameraController->RemainingVideoRecordingTime();
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController::SetPathnamesToNewStorageL - video mode not yet initialized" ));
+TRAPD( err, iVideoTimeRemaining = CalculateVideoTimeRemainingL() );
+if( KErrNone != err )
+{
+iVideoTimeRemaining = 0;
+}
+}
+}
+}
+// The engine is not yet prepared, the folder will be checked when the engine preparation
+// takes place. The controller also checks the state of iSetNewPathnamesPending when
+// preparation completes, just in case preparation is currently in progress.
+else
+{
+iSetNewPathnamesPending = aMediaStorage;
+}
+NotifyControllerObservers( ECamEventSaveLocationChanged );
+PRINT(_L("Camera <= CCamAppController::SetPathnamesToNewStorageL" ))
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetTextSettingValueL
+// Sets a new text value for the specified setting
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetTextSettingValueL(       TInt   aSettingItem,
+const TDesC& aSettingValue )
+{
+// Update the relevant settings model.
+iSettingsModel->SetTextSettingValueL( aSettingItem, aSettingValue );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TextSettingValue
+// Returns the current text value for the specified setting
+// ---------------------------------------------------------------------------
+//
+TPtrC
+CCamAppController::TextSettingValue( TInt aSettingItem ) const
+{
+// Query the relevant settings model.
+return iSettingsModel->TextSettingValue( aSettingItem );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SettingValueEnabled
+// Returns whether a particular setting value can be set or not.
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::SettingValueEnabled( TInt aSettingItem,
+TInt aSettingValue ) const
+{
+return iSettingsModel->SettingValueEnabled( aSettingItem, aSettingValue );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::LoadStaticSettingsL
+// Loads the static settings from shared data
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::LoadStaticSettingsL( TBool aIsEmbedded )
+{
+OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMAPPCONTROLLER_LOADSTATICSETTINGSL, "e_CCamAppController_LoadStaticSettingsL 1" );
+PRINT(_L("Camera => CCamAppController::LoadStaticSettingsL" ))
+iSettingsModel->LoadStaticSettingsL( aIsEmbedded );
+// Cache the image 'add to album' setting in the saving active object
+// it will change infrequently
+TInt value = iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoStoreInAlbum );
+TUint32 defaultAlbumId = static_cast<TUint32>(
+IntegerSettingValue( ECamSettingItemDefaultAlbumId ));
+iImageSaveActive->SetAddImageToAlbum( value == ECamSettYes,
+defaultAlbumId );
+// Ensure that the navipane is upto date with the current save location.
+if ( !aIsEmbedded )
+{
+NotifyControllerObservers( ECamEventAudioMuteStateChanged );
+NotifyControllerObservers( ECamEventVideoQualityChanged );
+}
+NotifyControllerObservers( ECamEventSaveLocationChanged );
+NotifyControllerObservers( ECamEventVideoStabChanged );
+if ( iConfigManager  && iConfigManager->IsLocationSupported() )
+{
+NotifyControllerObservers( ECamEventLocationSettingChanged );
+}
+NotifyControllerObservers( ECamEventVideoFileTypeChanged );
+NotifyControllerObservers( ECamEventImageQualityChanged );
+NotifyControllerObservers( ECamEventContAFStateChanged );
+PRINT(_L("Camera <= CCamAppController::LoadStaticSettingsL" ))
+OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMAPPCONTROLLER_LOADSTATICSETTINGSL, "e_CCamAppController_LoadStaticSettingsL 0" );
+}
+// ---------------------------------------------------------------------------
+// DynamicSettingDefaultValue
+// Get the setting default value.
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::DynamicSettingDefaultValue( TInt aSettingId ) const
+{
+return iSettingsModel->DynamicSettingDefaultValue( aSettingId );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetDynamicSettingsToDefaults
+// Sets all dynamic settings to their defaults.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetDynamicSettingsToDefaults()
+{
+iSettingsModel->SetDynamicSettingsToDefaults();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetDynamicSettingsToDefaults
+// Sets a dynamic setting to its default.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetDynamicSettingToDefault(TInt aSettingItem)
+{
+iSettingsModel->SetDynamicSettingToDefault(aSettingItem);
+}
+// ---------------------------------------------------------------------------
+// SetDynamicSettingToSceneDefaultL
+//
+// Set the dynamic setting identified by aSettingId to scene default.
+// Because video and photo scenes can have sama identifiers, aVideoScene
+// is needed to decide which ones to look for.
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::SetDynamicSettingToSceneDefaultL( TInt  aSceneId,
+TInt  aSceneField,
+TInt  aSettingId,
+TBool aVideoScene )
+{
+return iSettingsModel->SetDynamicSettingToSceneDefaultL( aSceneId,
+aSceneField,
+aSettingId,
+aVideoScene );
+}
+#ifdef PRODUCT_USES_GENERIC_SETUP_INDICATOR
+// ---------------------------------------------------------------------------
+// CCamAppController::VideoSceneDefaultsAreSet
+// Returns whether the video setup settings are set to the defaults
+// for its current scene.
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::VideoSceneDefaultsAreSet()
+{
+return iSettingsModel->VideoSceneDefaultsAreSet();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PhotoSceneDefaultsAreSet
+// Returns whether the photo setup settings are set to the defaults
+// for its current scene.
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::PhotoSceneDefaultsAreSet()
+{
+return iSettingsModel->PhotoSceneDefaultsAreSet();
+}
+#endif // PRODUCT_USES_GENERIC_SETUP_INDICATOR
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentFullFileName
+// ---------------------------------------------------------------------------
+//
+const TDesC&
+CCamAppController::CurrentFullFileName() const
+{
+PRINT1( _L("Camera => CCamAppController::CurrentFullFileName, index:%d"), iCurrentImageIndex );
+const TDesC& name( BurstCaptureArray()->FileName( iCurrentImageIndex ) );
+if( name != KNullDesC )
+{
+PRINT1( _L("Camera <= CCamAppController::CurrentFullFileName, return:[%S]"), &name );
+}
+else
+{
+PRINT( _L("Camera <= CCamAppController::CurrentFullFileName, name not set.") );
+}
+return name;
+}
+const TDesC&
+CCamAppController::CurrentVideoFileName() const
+{
+return iSuggestedVideoPath;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CCamAppController
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// ---------------------------------------------------------------------------
+//
+CCamAppController::CCamAppController()
+: iBusyFlags( EBusyNone )
+, iDiskCriticalLevel   ( KErrNotFound )
+, iRamDiskCriticalLevel( KErrNotFound )
+, iImageOrientation( ECamOrientation0 )
+, iLastImageOrientation( ECamOrientation0 )
+{
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ConstructL
+// Symbian 2nd phase constructor can leave.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ConstructL()
+{
+PRINT( _L("Camera => CCamAppController::ConstructL"));
+iPendingAFRequest=0;
+iCurrentAFRequest=0;
+iNoBurstCancel=EFalse;
+PRINT( _L("Camera <> CCamAppController::ConstructL - constructing Configuration Manager"));
+iConfiguration = CCamConfiguration::NewL();
+CCamFolderUtility::ResetCounters( iMonthFolderCounters );
+iCaptureKeyPressedWhileImageSaving = EFalse;
+iCaptureModeTransitionInProgress = ETrue;
+iSettingsModel = CCamSettingsModel::NewL( *iConfiguration );
+iSettingsModel->AttachObserverL( this );
+// Get the config pointer from settings model
+iConfigManager = static_cast<CCamSettingsModel*>(iSettingsModel)->UiConfigManagerPtr();
+RArray<TInt> supportedValues;
+CleanupClosePushL( supportedValues );
+// Get the EV slider info
+// these values should be read before camsettingsprovided is constructd
+// as the EV step value is needed during the construction of camsettingsprovider.
+iConfigManager->SupportedEVSettingsL( supportedValues );
+if ( supportedValues.Count() > 0 )
+{
+iEvRange.iMinValue     = supportedValues[0];
+iEvRange.iMaxValue     = supportedValues[1];
+iEvRange.iStepsPerUnit = supportedValues[2];
+}
+CleanupStack::PopAndDestroy( &supportedValues );
+// The Settings Model handles the previews at the moment
+iSettingsPreviewHandler = static_cast<CCamSettingsModel*>( iSettingsModel );
+//iSettingProvider = CCamConstantSettingProvider::NewL( *this );
+iSettingProvider = CCamSettingProvider::NewL( *this, iSettingsModel );
+iDeepSleepTimer = CCamTimer::NewL( KDeepSleepTimeout,
+TCallBack( CCamAppController::DeepSleepTimeout, this ) );
+iIdleTimer             = CCamTimer::NewL( KIdleTimeout,
+TCallBack( CCamAppController::IdleTimeoutL, this ) );
+iImageSaveActive       = CCamImageSaveActive::NewL( *this , *this );
+iCaptureArray          = CCamBurstCaptureArray::NewL( *iImageSaveActive );
+iRotationArray         = CCamBurstCaptureArray::NewL( *iImageSaveActive );
+iSequenceFilenameArray = new( ELeave ) CDesCArraySeg( KTimelapseArrayGranularity );
+iSoundPlayer           = CCamAudioPlayerController::NewL( *this, *this );
+if ( iConfigManager && iConfigManager->IsLensCoverSupported() )
+{
+// create property watcher for slide state
+PRINT( _L("Camera <> CCamAppController: Define Camera slider P&S key..") );
+// Whole slider position reading could be removed after PCFW has implemented
+// creation for KLensCoverStatus key
+TInt sliderPosition;
+TInt err = RProperty::Get(
+CameraPlatPSKeys::KPSCameraPlatUid,
+CameraPlatPSKeys::KLensCoverStatus,
+sliderPosition );
+if( err != KErrNone )
+{
+iSlideStateWatcher     = CCamPropertyWatcher::NewL( *this,
+NMusResourceApi::KCategoryUid,
+NMusResourceApi::KCameraAvailability );
+}
+else
+{
+iSlideStateWatcher     = CCamPropertyWatcher::NewL( *this,
+CameraPlatPSKeys::KPSCameraPlatUid,
+CameraPlatPSKeys::KLensCoverStatus );
+}
+}
+if ( iConfigManager && iConfigManager->IsKeyLockWatcherSupported() )
+{
+iKeyLockStatusWatcher  = CCamPropertyWatcher::NewL( *this,
+KPSUidAvkonDomain,
+KAknKeyguardStatus );
+}
+// read central repository value indicating whether camera shutter sound
+// should be played always or depending on the current profile setting
+CRepository* cr = CRepository::NewLC( KCRUidCamcorderFeatures );
+TInt value;
+TInt err;
+User::LeaveIfError( cr->Get( KCRCamShutterSound, value ) );
+CleanupStack::PopAndDestroy( cr );
+iShutterSndAlwaysOn = value;
+// get data for monitoring free RAM during sequence capture
+CamUtility::GetPsiInt( ECamPsiSnapshotSize, iSnapshotDataSize );
+iConfiguration->GetPsiIntArrayL( ECamPsiJpegDataSizes, iJpegDataSizes );
+iConfiguration->GetPsiIntArrayL( ECamPsiSequencePostProcessDataSizes,
+iSequencePostProcessDataSizes );
+if ( iConfigManager && iConfigManager->IsCaptureToneDelaySupported() )
+{
+TInt captureToneDelay = iConfigManager->CaptureToneDelay();
+TCallBack captureToneCb( CCamAppController::CaptureToneDelayTimeout, this );
+iCaptureToneDelayTimer =
+CCamTimer::NewL( captureToneDelay * KMicroSecsInMilliSec,
+captureToneCb );
+}
+PRINT( _L("Camera <> CCamAppController: Define Camera focused P&S key..") );
+err = RProperty::Define( KPSUidCamcorderNotifier,
+KCCorFocused,
+RProperty::EInt );
+if ( KErrNone != err )
+{
+// Error handling. Remove warning.
+}
+if ( iConfigManager  && iConfigManager->IsPublishZoomStateSupported() )
+{ // Publish zoom state
+iContextFwClient = CCFClient::NewL( *this );
+// Defining the context using the Context Framework.
+err = iContextFwClient->DefineContext(
+KCamContextSource,
+KCamContextType,
+KCamContextSecurity );
+if( KErrNone == err )
+{
+iDefineContextSuccessful = ETrue;
+PublishZoomStateL( EFalse );
+}
+else
+{
+// We make sure that we dont proceed with publishing the zoom state
+// if the context definition fails.
+iDefineContextSuccessful = EFalse;
+}
+} // Publish zoom state
+iLocationTrailStarted = EFalse;
+CamUtility::GetPsiInt( ECamPsiMaxBurstCapture, iLongSequenceLimit );
+User::LeaveIfError( iFs.Connect() );
+iDriveChangeNotifier = CCamDriveChangeNotifier::NewL( iFs, *this );
+PRINT( _L("Camera <= CCamAppController::ConstructL"));
+}
+/*
+* CCamAppController::PublishZoomStateL
+*/
+void CCamAppController::PublishZoomStateL( const TBool aEnabled )
+{
+// We publish the zoom state only when context definition is
+// successful. the value of the zoom state is controlled by the
+// boolean flag "aEnabled".
+if ( iConfigManager  && iConfigManager->IsPublishZoomStateSupported() )
+{
+if ( iDefineContextSuccessful )
+{
+CCFContextQuery* query = CCFContextQuery::NewLC();
+query->SetSourceL( KCamContextSource );
+query->SetTypeL( KCamContextType );
+RContextObjectArray result;
+TInt err = iContextFwClient->RequestContext( *query, result );
+if( err == KErrNone  && result.Count() > 0 )
+{
+if ( aEnabled )
+{
+result[0]->SetValueL( KCamContextValueEnable );
+}
+else
+{
+result[0]->SetValueL( KCamContextValueDisable );
+}
+TInt err = iContextFwClient->PublishContext( *result[0] );
+if ( err != KErrNone )
+{
+// Define how to handle the error case.
+}
+}
+else
+{
+// ignoring the error case.
+}
+result.ResetAndDestroy();
+CleanupStack::PopAndDestroy( query );
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsViewFinding
+// Check if viewfinder is active
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsViewFinding() const
+{
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicInvalidState ) );
+return ( iCameraController
+&& iCameraController->ViewfinderState() == ECamTriActive );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::NotifyControllerObservers
+// Notify the controller observers that a new controller event has occurred
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::NotifyControllerObservers( TCamControllerEvent aEvent,
+TInt                aError ) const
+{
+PRINT( _L("Camera => CCamAppController::NotifyControllerObservers"));
+// We might need to stop notification for some time.
+if( !iMuteNotifications )
+{
+for ( TInt i = 0; i < iControllerObservers.Count(); i++ )
+{
+// NON-NULL checked when adding observers.
+// If the notification leaves, continue for the other observers
+TRAP_IGNORE( iControllerObservers[i]->HandleControllerEventL( aEvent, aError ) )
+}
+}
+PRINT( _L("Camera <= CCamAppController::NotifyControllerObservers"));
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::EnterViewfinderMode( const TCamCameraMode& aMode )
+{
+PRINT( _L("Camera => CCamAppController::EnterViewfinderMode"));
+TInt error( KErrNone );
+iPendingRelease = EFalse;
+// start monitoring mmc dismount notifications
+StartDismountMonitoring();
+if ( iConfigManager && iConfigManager->IsPublishZoomStateSupported() )
+{
+TRAP_IGNORE ( PublishZoomStateL( ETrue ) );
+}
+// Clear these just in case some video prepare is pending.
+iVideoPrepareNeeded = EFalse;
+if( ECamControllerVideo == aMode )
+{
+// Filename generation needs to be done in all case, not only
+// when the current path is null.
+// if( KNullDesC() == iSuggestedVideoPath )
+{
+TRAP_IGNORE( GenerateNextValidVideoPathL() );
+}
+// Clear this to be sure it doesn't block recording
+iVideoRequested = EFalse;
+SetTargetMode     ( ECamControllerVideo  );
+SetTargetImageMode( ECamImageCaptureNone );
+// shutdown the orientation channel when going to videomode
+		if ( iConfigManager && iConfigManager->IsOrientationSensorSupported() )
+			{
+	    TRAP_IGNORE( UpdateSensorApiL( EFalse ) );
+			}
+}
+else if( ECamControllerImage == aMode )
+{
+SetTargetMode     ( ECamControllerImage    );
+//    SetTargetImageMode( ECamImageCaptureSingle );
+SetTargetImageMode( CurrentImageModeSetup() );
+}
+else
+{
+SetOperation( ECamStandby, KErrGeneral );
+return;
+}
+iInfo.iTargetVfState = ECamTriActive;
+if( !Busy() )
+{
+TRAP( error, IssueModeChangeSequenceL() );
+if ( KErrNone    != error
+&& ECamStandby != iInfo.iOperation )
+{
+SetOperation( ECamStandby, error );
+}
+}
+else
+{
+// operation will continue when busy sequence or request completes
+}
+PRINT( _L("Camera <= CCamAppController::EnterViewfinderMode"));
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::ExitViewfinderMode( const TCamCameraMode& aMode )
+{
+PRINT( _L("Camera => CCamAppController::ExitViewfinderMode"));
+// The check here is to ensure that the viewfinder isn't stopped by the still precapture
+// view when it has just lost the foreground to the video precapture view and vice versa.
+// In that case the mode in parameter would not match the target mode.
+if( iInfo.iOperation != ECamStandby )
+{
+if ( aMode == iInfo.iTargetMode )
+{
+iInfo.iTargetVfState = ECamTriIdle;
+SetTargetImageMode( ECamImageCaptureNone );
+if( !Busy() )
+{
+if ( iConfigManager && iConfigManager->IsPublishZoomStateSupported() )
+{
+TRAP_IGNORE ( PublishZoomStateL( EFalse ) );
+}
+TRAPD( error, IssueDirectRequestL( ECamRequestVfRelease ) );
+if ( KErrNone             != error
+&& ECamStandby != iInfo.iOperation )
+{
+SetOperation( ECamStandby, error );
+}
+}
+else
+{
+// operation will continue when busy sequence or request completes
+}
+}
+}
+PRINT( _L("Camera <= CCamAppController::ExitViewfinderMode"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StartViewFinder();
+// Non-leaving version of StartViewFinderL()
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StartViewFinder()
+{
+PRINT( _L("Camera => CCamAppController::StartViewFinder" ))
+iInfo.iTargetVfState = ECamTriActive;
+if( !Busy() )
+{
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_STARTVIEWFINDER, "e_CAM_APP_VF_INIT 0" );   //CCORAPP_APP_VF_INIT_END
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPCONTROLLER_STARTVIEWFINDER, "e_CAM_APP_OVERLAY_INIT 0" ); //CCORAPP_APP_OVERLAY_INIT_END
+TRAPD( error, IssueDirectRequestL( ECamRequestVfStart ) );
+if ( KErrNone    != error
+&& ECamStandby != iInfo.iOperation )
+{
+PRINT( _L("Camera <> CCamAppController::StartViewFinder - [ERROR] VF start failed, go to standby" ))
+SetOperation( ECamStandby, error );
+}
+}
+else
+{
+// Vf started at earliest convenient time when ongoing requests finish.
+}
+PRINT(_L("Camera <= CCamAppController::StartViewFinder") );
+}
+// ---------------------------------------------------------------------------
+// StopViewFinder
+// Stop the viewfinder immediately
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StopViewFinder()
+{
+PRINT( _L("Camera => CCamAppController::StopViewFinderNow" ) )
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicInvalidState ) );
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_STOPVIEWFINDER, "e_CAM_APP_STOP_VF 1" );  //CCORAPP_STOP_VF_START
+if ( iBacklightTimer && iBacklightTimer->IsActive() )
+{
+iBacklightTimer->Cancel();
+}
+// Only stop if active.
+// Idle and inactive need no action at this point.
+if( ECamTriActive == iCameraController->ViewfinderState() )
+{
+iInfo.iTargetVfState = ECamTriInactive;
+// Can only fail to OOM when state is checked.
+TRAPD( error, iCameraController->DirectRequestL( ECamRequestVfStop ) );
+if( KErrNone             != error
+&& ECamStandby != iInfo.iOperation )
+{
+SetOperation( ECamStandby, error );
+}
+}
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPCONTROLLER_STOPVIEWFINDER, "e_CAM_APP_STOP_VF 0" ); //CCORAPP_STOP_VF_END
+PRINT( _L("Camera <= CCamAppController::StopViewFinderNow" ) )
+}
+// ---------------------------------------------------------------------------
+// StopViewFinderEcam
+// Stop the viewfinder immediately without changing states
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::StopViewFinderEcam()
+{
+PRINT( _L("Camera => CCamAppController::StopViewFinderEcam" ) )
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicInvalidState ) );
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_STOPVIEWFINDERECAM, "e_CAM_APP_STOP_VF 1" );  //CCORAPP_STOP_VF_START
+// Trap and ignore error
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestVfStopEcam ) );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPCONTROLLER_STOPVIEWFINDERECAM, "e_CAM_APP_STOP_VF 0" ); //CCORAPP_STOP_VF_END
+PRINT( _L("Camera <= CCamAppController::StopViewFinderEcam" ) )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::FreezeViewFinder
+// Copy the next viewfinder frame then stop the viewfinder
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::FreezeViewFinder( TBool aFreeze )
+{
+// If the viewfinder needs to freeze
+if ( aFreeze )
+{
+PERF_MESSAGE_L2( EPerfMessagePausingViewFinder );
+iFreezeViewFinder  = ETrue;
+iUpdateFrozenFrame = ETrue;
+}
+// Restarting the viewfinder
+else
+{
+iFreezeViewFinder  = EFalse;
+iUpdateFrozenFrame = EFalse;
+if ( ECamTriActive != iCameraController->ControllerInfo().iVfState )
+{
+StartViewFinder();
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetKeyUp
+// Set  iKeyUP value which is used to determine if burst
+// timer should be activated or not
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetKeyUp( TBool aValue /*= EFalse*/ )
+{
+PRINT1(_L("Camera => CCamAppController::SetKeyUp, iKeyUP=%d"), aValue );
+iKeyUP=aValue;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DoCaptureL
+// Initiate image capture
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::DoCaptureL()
+{
+PRINT( _L("Camera => CCamAppController::DoCaptureL()"));
+PRINT2(_L("Camera <> mode[%s] imagemode[%s]"), KCamModeNames[iInfo.iMode], KCamImageModeNames[iInfo.iImageMode] );
+// ReleaseArray();
+if( iImageSaveActive->Count() <= 0 )
+{
+ReleaseArray( ETrue );
+}
+iCurrentImageIndex = 0;
+iArrayUsageCount   = KImageArrayUsers;
+iCameraWoken = EFalse;
+TBool continueWithCapture = ETrue;
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// Capture needed as fast as possible.
+// Use direct stopping of viewfinder
+// unless there are settings pending,
+// otherwise cancel capture
+if ( !IsFlagOn( iBusyFlags, EBusySetting ) )
+{
+// Stop VF for burst mode or for secondary or
+// embedded camera before capturing.
+// VF stopping will increase capture lag.
+if ( iInfo.iImageMode == ECamImageCaptureBurst ||
+iInfo.iActiveCamera == ECamActiveCameraSecondary ||
+appUi->IsEmbedded() )
+{
+StopViewFinder();
+}
+}
+else
+{
+continueWithCapture = EFalse;
+}
+switch( iInfo.iImageMode )
+{
+// -----------------------------------------------------
+// Burst capture
+case ECamImageCaptureBurst:
+{
+PRINT( _L("Camera <> CCamAppController::DoCaptureL .. case ECamImageCaptureBurst") );
+/*
+TCamPhotoSizeId sizeId( GetCurrentImageResolution() );
+TInt memoryNeed( iJpegDataSizes[sizeId]
++ iSequencePostProcessDataSizes[sizeId]
++ iSnapshotDataSize );
+TInt memoryFree( 0 );
+HAL::Get( HALData::EMemoryRAMFree, memoryFree ); // error ignored
+if( memoryFree < memoryNeed )
+{
+PRINT( _L( "Camera <> Not enough memory for more burst captures - complete capture" ) );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// Force re-prepare of engine
+appUi->HandleCommandL( ECamCmdSequence );
+// Display out of memory note
+NotifyControllerObservers( ECamEventSnapshotReady, KErrNoMemory );
+// Return app to burst precapture state from burst in-capture
+SetOperation( ECamNoOperation );
+NotifyControllerObservers( ECamEventCaptureComplete );
+// Force update of UI furniture
+NotifyControllerObservers( ECamEventCounterUpdated );
+appUi->UpdateCba();
+iCaptureRequested = EFalse;
+HandleCaptureCompletion();
+continueWithCapture = EFalse;
+}
+else
+{
+iSequenceCaptureInProgress = ETrue;
+iActualBurstCount = 0;
+FreezeViewFinder( ETrue );
+// Stop the screensaver from coming on when burst mode is active
+EnableScreenSaver( EFalse );
+// Make navi counter update itself
+NotifyControllerObservers( ECamEventCounterUpdated );
+}
+*/
+if( !appUi->SelfTimerEnabled() )
+{
+// Start timer to change burst mode to press and hold
+// if not determined to be short burst before that.
+//One such case is if capturekeyup event has occured before
+//DocaptureL method
+if( !iKeyUP && !iNoBurstCancel )
+{
+StartBurstTimerL();
+}
+}
+iSequenceCaptureInProgress = ETrue;
+iValueIsStored = EFalse;
+FreezeViewFinder( ETrue );
+EnableScreenSaver( EFalse );
+	  if(  iBacklightTimer
+&& !iBacklightTimer->IsActive() )
+{
+iBacklightTimer->Start( 0,
+KBacklighTimerInterval,
+TCallBack( ResetInactivityTimer, this ) );
+}
+NotifyControllerObservers( ECamEventCounterUpdated );
+break;
+}
+// -----------------------------------------------------
+// Timelapse capture
+case ECamImageCaptureTimeLapse:
+{
+PRINT( _L("Camera <> CCamAppController::DoCaptureL .. case ECamImageCaptureTimeLapse") );
+iSequenceCaptureInProgress = ETrue;
+// Stop the screensaver from coming on when burst mode is active
+EnableScreenSaver( EFalse );
+// Get the remaining image count and only start the timer for the next capture if there is enough
+// space, taking into account that the current capture will also use up one image
+TCamMediaStorage storage( (TCamMediaStorage)IntegerSettingValue( ECamSettingItemPhotoMediaStorage ) );
+TCamPhotoSizeId  sizeId ( GetCurrentImageResolution() );
+TInt remainingCount = ImagesRemaining( storage, ETrue, sizeId );
+// Check if the advanced sequence is limited (by starting from selftimer)
+if( remainingCount  >= 1
+&& iRequestedCaptureCount <= TimeLapseImageCount()+1 )
+{
+iCompleteTimeLapsePending = ETrue;
+}
+// if there isn't space for this capture (e.g. some memory has been used since the timer was initiated
+// or there isn't enough space to initiate a further capture
+else if ( remainingCount <= 1 )
+{
+PRINT( _L("Camera <> CCamAppController::DoCaptureL .. only space for one capture, stop timer") );
+// The timer is no longer needed
+if ( iTimeLapseTimer )
+{
+iTimeLapseTimer->Cancel();
+delete iTimeLapseTimer;
+iTimeLapseTimer = NULL;
+}
+// if there isn't even enough space for this capture
+if ( remainingCount < 1 )
+{
+// complete the timelapse capture now (prevent the current capture from starting)
+continueWithCapture = EFalse;
+iArrayUsageCount = 0;
+CompleteTimeLapseOperation();
+}
+else // if there isn't enough space to initiate a further capture
+{
+// ensure that the time lapse capture completes after the current capture
+iCompleteTimeLapsePending = ETrue;
+}
+}
+else // there is space to initiate a further capture
+{
+PRINT( _L("Camera <> CCamAppController::DoCaptureL .. space for more than this capture, timer set on..") );
+if ( !iTimeLapseTimer )
+{
+RestartTimeLapseTimerL();
+//Products which support autofocus needs to reduce time for second picture
+//about the time needed by autofocus.
+if( iConfigManager && iConfigManager->IsAutoFocusSupported()
+&& !CurrentSceneHasForcedFocus() )
+{
+iTimeLapseStartTime = iTimeLapseStartTime - TTimeIntervalSeconds( KFocusingDurationSeconds );
+}
+}
+}
+break;
+}
+// -----------------------------------------------------
+// Single capture
+case ECamImageCaptureSingle:
+PRINT( _L("Camera <> CCamAppController::DoCaptureL .. case ECamImageCaptureSingle") );
+// Should not take so long to get the image captured and saved,
+// but
+EnableScreenSaver( EFalse );
+SetCaptureKeyPressedWhileImageSaving(EFalse);
+break;
+// -----------------------------------------------------
+default:
+PRINT(_L("Camera <> Not in any image capture mode, LEAVE!!"));
+User::Leave( KErrGeneral );
+break;
+// -----------------------------------------------------
+}
+if ( continueWithCapture )
+{
+IssueRequestL( ECamRequestImageCapture );
+// Operation in progress is updated in HandleCameraEventL
+// store the orientation at capture time, needed in thumbnail creation
+iCaptureOrientation = iLastImageOrientation;
+}
+iCaptureStoppedForUsb = EFalse;
+PRINT( _L("Camera <= CCamAppController::DoCaptureL()"));
+return continueWithCapture;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DoRecord
+// Initiate video recording
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DoRecord()
+{
+PRINT( _L("Camera => CCamAppController::DoRecord") );
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicInvalidState ) );
+StopIdleTimer();
+// No key sounds when recording
+TRAP_IGNORE( iSoundPlayer->DisableAllKeySoundsL() );
+PRINT( _L("Camera <> Requesting video capture start..") );
+TRAPD( error, IssueRequestL( ECamRequestVideoStart ) );
+PRINT1( _L("Camera <> ..request issued, status:%d"), error );
+if( KErrNone != error ) SetOperation( ECamStandby, error );
+else                    SetOperation( ECamCapturing );
+// Request is handled
+iVideoRequested = EFalse;
+iCaptureStoppedForUsb = EFalse;
+PRINT( _L("Camera <= CCamAppController::DoRecord") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ReserveFileNamesL
+// Reserve a set of filenames for a burst capture
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::ReserveFileNamesL(
+const TCamCameraMode&        aCaptureMode,
+const TCamImageCaptureMode&  aImageMode,
+TBool                  aForcePhoneMem /*= EFalse*/ )
+{
+PRINT( _L("Camera => CCamAppController::ReserveFileNamesL") )
+TInt captureCount = 1;
+TInt store        = ECamMediaStorageNone;
+TBuf<KMaxExtension> extension;
+// If the next file will be a photo
+if ( ECamControllerImage == aCaptureMode )
+{
+extension = KImageExtension;
+}
+// Otherwise the next file will be a video
+else
+{
+#ifndef __WINS__
+TCamVideoFileType fileType = static_cast<TCamVideoFileType>
+( IntegerSettingValue( ECamSettingItemVideoFileType ) );
+extension = ( ECamVideoMpeg4 == fileType )
+? KVideoMP4Extension
+: KVideo3GPExtension;
+#else
+extension = KVideo3GPExtension;
+#endif
+}
+store = ( ECamControllerImage == aCaptureMode ) ?
+CurrentPhotoStorageLocation() : CurrentVideoStorageLocation();
+TPath basePath;
+// Take a snapshot of the date - to ensure a sequence on a date boundary isn't split into
+// different months
+TTime now;
+now.HomeTime();
+// Need to check that there is enough space for the files. If this is a sequence of 20 images or
+// less then ensure there is enough space in the current folder, otherwise only one space is needed
+TInt guaranteedGroup = 1;
+if ( captureCount < CCamFolderUtility::KMaxGuaranteedBurstGroup )
+{
+guaranteedGroup = captureCount;
+}
+// Leaves if errors generating the path
+CCamFolderUtility::GetBasePathL( iMonthFolderCounters,
+store,
+basePath,
+aCaptureMode,
+ETrue,
+guaranteedGroup,
+now );
+iCurrentStorage = static_cast<TCamMediaStorage>( store );
+//  TInt numberSettingId( KErrNotFound );
+TInt typeSettingId( KErrNotFound );
+TInt baseSettingId( KErrNotFound );
+TInt counter( 0 );
+if( ECamControllerVideo == aCaptureMode )
+{
+//    numberSettingId = ECamSettingItemVideoNumber;
+counter         = IntegerSettingValue( ECamSettingItemVideoNumber );
+typeSettingId   = ECamSettingItemVideoNameBaseType;
+baseSettingId   = ECamSettingItemVideoNameBase;
+}
+else
+{
+//    numberSettingId = ECamSettingItemPhotoNumber;
+counter         = iImageNumberCache;
+typeSettingId   = ECamSettingItemPhotoNameBaseType;
+baseSettingId   = ECamSettingItemPhotoNameBase;
+}
+//  TInt counter( IntegerSettingValue( numberSettingId ) );
+TBuf<KCamMaxDateLen> dateNameBase;
+TPtrC nameBase;
+if ( ECamNameBaseDate == iSettingsModel->IntegerSettingValue( typeSettingId ) )
+{
+CamUtility::FormatDateFileNameL( dateNameBase );
+nameBase.Set( dateNameBase );
+}
+else
+{
+nameBase.Set( TextSettingValue( baseSettingId ) );
+}
+RFs rfs;
+User::LeaveIfError( rfs.Connect() );
+CleanupClosePushL( rfs );
+TEntry entry;
+TInt namedImages = 0;
+while ( namedImages < captureCount )
+{
+// Generate new name
+TFileName newFileName;
+CamUtility::FormatFileName( counter, nameBase, newFileName );
+TFileName newPath( basePath );
+newPath.Append( newFileName );
+newPath.Append( extension );
+// if there is no file in the current location with this name
+TEntry entry;  // Prevent LINT error
+TInt ferr = rfs.Entry( newPath, entry );
+if ( KErrNotFound == ferr )
+{
+// A file with that name was not found, so the filename is okay.
+PRINT( _L("Camera <> Filename OK.") )
+namedImages++;
+StoreNextFileNameL( newPath );
+// If this is time lapse capture then the full set of file names
+// will be needed for the 'delete sequence' option. The burst capture array
+// in timelapse only holds data for one item at a time so a separate array
+// is used to keep track of all the images file names. The redundancy in filename
+// storage is limited to a single file name.
+if ( ECamImageCaptureTimeLapse == aImageMode )
+{
+TRAP_IGNORE( iSequenceFilenameArray->AppendL( newPath ) );
+// Update the images captured count
+NotifyControllerObservers( ECamEventCounterUpdated );
+}
+counter++;
+}
+else if ( KErrNone == ferr )
+{
+// A file with that name exists already. Increment the counter and try again.
+PRINT( _L("Camera <> Filename already in use!") )
+counter++;   // Try the next index number
+}
+else
+{
+// There was some other error. Can not save file -> Leave.
+PRINT1( _L("Camera <> File server returned error: %d"), ferr );
+User::Leave( ferr );
+}
+}
+CleanupStack::PopAndDestroy( &rfs );
+// SetIntegerSettingValueL( numberSettingId, counter );
+if( ECamControllerVideo == aCaptureMode )
+{
+SetIntegerSettingValueL( ECamSettingItemVideoNumber, counter );
+}
+else
+{
+// SetIntegerSettingValueL called when capture ends.
+iImageNumberCache = counter;
+}
+PRINT( _L("Camera <= CCamAppController::ReserveFileNamesL") )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CreateDummyFileL
+// Create dummy file ready for image storage
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CreateDummyFileL( RFs& aFs, const TDesC& aFullPath )
+{
+PRINT1( _L("Camera => CCamAppController::CreateDummyFileL [%S]"), &aFullPath );
+RFile file;
+CleanupClosePushL( file );
+TInt err = file.Create( aFs, aFullPath, EFileWrite );
+if ( err == KErrNone )
+{
+// Still image files are made writable and non-hidden
+// just before the save operation
+// file is set to hidden so that media gallery does not detect it
+file.SetAtt( KEntryAttReadOnly|KEntryAttHidden, 0 );
+}
+CleanupStack::PopAndDestroy( &file );
+PRINT1( _L("Camera <= CCamAppController::CreateDummyFileL, status:%d"), err );
+return err;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StoreNextFileNameL
+// Add newly generated filename to array of names
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StoreNextFileNameL( const TDesC& aFullPath )
+{
+PRINT( _L("Camera => CCamAppController::StoreNextFileNameL") );
+TParse parse;
+parse.Set( aFullPath, NULL, NULL );
+// Store the path + filename and plain filename for future reference
+if( ECamControllerVideo == iInfo.iMode && BurstCaptureArray()->Count() > 0 )
+{
+BurstCaptureArray()->SetNameL( aFullPath, parse.Name(), 0 );
+}
+else
+{
+BurstCaptureArray()->SetNextNameL( aFullPath, parse.Name() );
+}
+PRINT( _L("Camera <= CCamAppController::StoreNextFileNameL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GenerateNextVideoFilePathL
+// Generate a new file name and full path to save the next
+// video
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::GenerateNextVideoFilePathL( TBool aForcePhoneMem )
+{
+PRINT1( _L( "Camera => CCamAppController::GenerateNextVideoFilePathL, force phone mem:%d" ), aForcePhoneMem )
+TInt store = IntegerSettingValue( ECamSettingItemVideoMediaStorage );
+TBuf<KMaxExtension> extension;
+#ifdef __WINS__
+extension = KVideo3GPExtension;
+#else
+// If the video file type is MP3, then display this icon.
+TCamVideoFileType fileType =
+static_cast<TCamVideoFileType>(
+IntegerSettingValue( ECamSettingItemVideoFileType ) );
+extension = (fileType == ECamVideoMpeg4)
+? KVideoMP4Extension
+: KVideo3GPExtension;
+#endif
+TBuf<KCamMaxDateLen> dateNameBase;
+TPtrC baseVideoName;
+if ( iSettingsModel->IntegerSettingValue(
+ECamSettingItemVideoNameBaseType ) == ECamNameBaseDate )
+{
+CamUtility::FormatDateFileNameL( dateNameBase );
+baseVideoName.Set( dateNameBase );
+}
+else
+{
+baseVideoName.Set( TextSettingValue( ECamSettingItemVideoNameBase ) );
+}
+TFileName nextFileName( baseVideoName );
+store = ( ECamControllerImage == iInfo.iMode ) ?
+CurrentPhotoStorageLocation() : CurrentVideoStorageLocation();
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( IsAppUiAvailable() &&
+appUi &&
+appUi->IsMemoryFullOrUnavailable( ECamMediaStorageCard ) &&
+ECamMediaStorageCard == store )
+{
+if ( ExistMassStorage() )
+{
+// with multiple drives, the mass memory is the default
+PRINT( _L("Camera <> Force ECamMediaStorageMassStorage") );
+store = ECamMediaStorageMassStorage;
+}
+else
+{
+PRINT( _L("Camera <> Force ECamMediaStoragePhone") );
+store = ECamMediaStoragePhone;
+}
+}
+TInt fileNameCounter = IntegerSettingValue( ECamSettingItemVideoNumber );
+// Update contents of iSuggestedVideoPath (drive and folders only)
+CCamFolderUtility::GetBasePathL( iMonthFolderCounters,
+store,
+iSuggestedVideoPath,
+ECamControllerVideo,
+ETrue );
+iCurrentStorage = static_cast<TCamMediaStorage>( store );
+// Update contents of iSuggestedVideoPath (appending filename and extension)
+CamUtility::GetUniqueNameL( iSuggestedVideoPath, nextFileName, fileNameCounter, extension );
+PRINT( _L( "Camera <= CamAppController::GenerateNextVideoFilePathL" ) )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GenerateNextValidVideoPathL
+// Generate a new file name and full path to save the next video.
+// If the generated file (using settings to suggest the drive) can not be opened
+// try again, forcing the file to be on C: instead.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::GenerateNextValidVideoPathL()
+{
+PRINT( _L("Camera => CCamAppController::GenerateNextValidVideoPathL()"));
+// If USB is active, use phone memory
+if( CamUtility::IsUsbActive() )
+{
+GenerateNextVideoFilePathL( ETrue );
+}
+else
+{
+// Generate a file path using the settings
+TRAPD( err, GenerateNextVideoFilePathL() );
+// If left (possibly due to corrupt MMC), try again with phone memory
+if ( err )
+{
+// If we have got here, we can't access MMC.
+// Don't switch to phone memory, but prepare the engine with a video
+// name in phone memory. This will be reset if needed when the user actually
+// starts recording
+PRINT( _L( "Could not generate next file path!  Corrupt MMC?" ) );
+GenerateNextVideoFilePathL( ETrue );
+}
+}
+PRINT( _L("Camera <= CCamAppController::GenerateNextValidVideoPathL()"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::GenerateNextValidImagesPathL
+// Generate a new path to save the next image.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::GenerateNextValidImagesPathL()
+{
+PRINT( _L("Camera => CCamAppController::GenerateNextValidImagesPathL()"));
+// Generate a file path using the settings
+// Ensure the image folder exists
+TFileName path;
+TInt storage = IntegerSettingValue( ECamSettingItemPhotoMediaStorage );
+CCamFolderUtility::GetBasePathL( iMonthFolderCounters,
+storage,
+path,
+ECamControllerImage,
+EFalse );
+iCurrentStorage = static_cast<TCamMediaStorage>( storage );
+PRINT( _L("Camera <= CCamAppController::GenerateNextValidImagesPathL()"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CaptureModeTranstionInProgress
+// Report whather a capture mode is currently being prepared
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::CaptureModeTransitionInProgress()
+{
+PRINT1( _L("Camera => CCamAppController::CaptureModeTransitionInProgress (%d)"), iCaptureModeTransitionInProgress )
+return iCaptureModeTransitionInProgress;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandleSaveEvent
+// From MCamImageSaveObserver.
+// Handle completion of image saving
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleSaveEvent( TCamSaveEvent aEvent )
+{
+PRINT3( _L( "Camera => CCamAppController::HandleSaveEvent .. event[%s] imagemode[%s] operation[%s]" ),
+KCamSaveEventNames       [aEvent          ],
+KCamImageModeNames       [iInfo.iImageMode],
+KCamCaptureOperationNames[iInfo.iOperation] )
+TBool mediaFileChanged = EFalse;
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( ( iCaptureArray->ImagesRemaining() <= 0 )
+&& appUi
+&& appUi->IsInPretendExit() )
+{
+ReleaseArray( ETrue );
+}
+if( ECamSaveEventCriticalError == aEvent )
+{
+PRINT( _L( "Camera <> CCamAppController::HandleSaveEvent: critical error, going to standby.." ) )
+SetOperation( ECamStandby, KErrGeneral );
+PRINT( _L( "Camera <= CCamAppController::HandleSaveEvent" ) )
+return;
+}
+if( aEvent == ECamSaveEventSaveError )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent - ECamSaveEventSaveError!") );
+if( iInfo.iImageMode == ECamImageCaptureBurst &&
+SequenceCaptureInProgress() )
+{
+// Cancel ongoing burst capture
+// Burst capture is normally cancelled by setting iRequestedBurstCount,
+// and actual cancelling is done when next imagedata arrives.
+// However, in this case camera is going to be released, and there won't
+// be next image data, so give ECamRequestImageCancel and capture
+// completion event here to avoid problems
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. Cancel burst due to error") );
+TRAP_IGNORE ( IssueDirectRequestL( ECamRequestImageCancel ) );
+NotifyControllerObservers( ECamEventCaptureComplete, KErrCancel );
+}
+else
+{
+PRINT( _L( "Camera <> CCamAppController::HandleSaveEvent: critical error, going to standby.." ) )
+SetOperation( ECamStandby, KErrGeneral );
+}
+PRINT( _L("Camera <= CCamAppController::HandleSaveEvent - ECamSaveEventSaveError!") );
+return;
+}
+// if a save completes
+if ( aEvent == ECamSaveEventComplete )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. ECamSaveEventComplete") );
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+if( ECamImageCaptureBurst != iInfo.iImageMode )
+{
+// Do not log in burst mode
+PERF_EVENT_END_L1( EPerfEventShotToSave );
+}
+#endif
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_HANDLESAVEEVENT, "e_CAM_PRI_SHOT_TO_SAVE 0" );  //CCORAPP_PRI_SHOT_TO_SAVE_END
+// Check that this is the completion of the last pending
+// single image save.
+// Note burst capture completion is handled separately
+TBool savedAll   = ( iImageSaveActive->Count()== 0                );
+TBool completing = ( ECamCompleting           == iInfo.iOperation );
+switch( iInfo.iImageMode )
+{
+case ECamImageCaptureNone: // In postcapture, waiting for saving
+case ECamImageCaptureSingle:
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. case ECamImageCaptureSingle/None") );
+if( savedAll )
+{
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMAPPCONTROLLER_HANDLESAVEEVENT, "e_CAM_PRI_SERIAL_SHOOTING 0" );    //CCORAPP_PRI_SERIAL_SHOOTING_END
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. calling HandleCaptureCompletion()") );
+if( !iSaveStarted )
+{
+HandleCaptureCompletion();
+NotifyControllerObservers( ECamEventCaptureComplete, KErrNone );
+}
+else
+{
+iSaveStarted = EFalse;
+}
+// If we have returned from postcapture to precapture before
+// the filename has been sent to the gallery (i.e. pressing back
+// key during image processing), iArrayUsageCount will be reduced
+// to zero and capture array will be released. In that case, we must
+// send the filename to gallery before it happens.
+if ( iArrayUsageCount == 1 )
+{
+NotifyControllerObservers( ECamEventMediaFileChanged );
+mediaFileChanged = ETrue;
+}
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( iImageSaveActive && IsAppUiAvailable() )
+{
+if( iImageSaveActive->Count() <= 0 && ECamViewStatePostCapture != appUi->CurrentViewState() )
+{
+ReleaseArray();
+}
+}
+}
+break;
+case ECamImageCaptureTimeLapse:
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. case ECamImageCaptureTimeLapse") );
+// If image capture has finished, but waiting for file to be saved.
+if( ECamNoOperation == iInfo.iOperation || ECamCompleting == iInfo.iOperation )
+{
+PRINT( _L("Camera <> CCamAppController .. current file saved, complete this capture") );
+SetOperation( ECamNoOperation );
+ReleaseArray();
+}
+break;
+case ECamImageCaptureBurst:
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. case ECamImageCaptureBurst") );
+// After the whole burst has stopped, we get Image Stop event from Camera Controller,
+// and enter completing state.
+if( completing && savedAll )
+{
+// Modify this event to "burst complete" one.
+aEvent = ECamSaveEventBurstComplete;
+}
+break;
+default:
+break;
+}
+NotifyControllerObservers( ECamEventSaveComplete );
+}
+if ( aEvent == ECamSaveEventStarted )
+{
+if( iInfo.iImageMode == ECamImageCaptureSingle )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSaveEvent .. Saving started") );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPCONTROLLER_HANDLESAVEEVENT, "e_CAM_APP_PREP_FOR_NEXT_SHOT 1" ); //CCORAPP_PREP_FOR_NEXT_SHOT_START
+HandleCaptureCompletion();
+NotifyControllerObservers( ECamEventCaptureComplete, KErrNone );
+NotifyControllerObservers( ECamEventSaveComplete );
+iCaptureRequested = EFalse;
+iSaveStarted = ETrue;
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMAPPCONTROLLER_HANDLESAVEEVENT, "e_CAM_APP_PREP_FOR_NEXT_SHOT 0" ); //CCORAPP_PREP_FOR_NEXT_SHOT_END
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMAPPCONTROLLER_HANDLESAVEEVENT, "e_CAM_PRI_SHOT_TO_SHOT 0" ); //CCORAPP_PRI_SHOT_TO_SHOT_END
+}
+}
+// If the user cancelled a save
+if ( aEvent == ECamSaveEventUserCancelled )
+{
+PRINT( _L( "Camera <> CCamAppController::HandleSaveEvent .. ECamSaveEventUserCancelled" ) )
+//iInfo.iImageMode = ECamImageModeNone;
+// Make sure that any further engine callbacks are ignored until next capture
+SetOperation( ECamNoOperation );
+// Delete dummy files for unsaved images
+TInt nextSavingImage = BurstCaptureArray()->NextFileIndex();
+TInt lastImage = BurstCaptureArray()->Count();
+TInt i;
+// delete the next and following files
+for ( i = nextSavingImage; i < lastImage; i++ )
+{
+SetAsCurrentImage( i );
+DeleteCurrentFile();
+}
+SetAsCurrentImage( 0 );
+// Empty out the array - this ensures the thumbnail view doesn't open
+BurstCaptureArray()->Reset();
+NotifyControllerObservers( ECamEventSaveCancelled );
+}
+// if a burst capture has completed
+if ( aEvent == ECamSaveEventBurstComplete )
+{
+CompleteBurstOperation();
+if( ECamCompleting == iInfo.iOperation )
+{
+PRINT( _L( "Camera <> CCamAppController::HandleSaveEvent .. completing burst capture" ) )
+SetOperation( ECamNoOperation );
+NotifyControllerObservers( ECamEventCaptureComplete, KErrNone );
+ReleaseArray();
+}
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMAPPCONTROLLER_HANDLESAVEEVENT, "e_CAM_PRI_SERIAL_SHOOTING 0" );  //CCORAPP_PRI_SERIAL_SHOOTING_END
+}
+else
+{
+if ( iImageSaveActive->Count() == 0 || aEvent == ECamSaveEventStarted )
+{
+iSaving = EFalse;
+}
+}
+if ( !mediaFileChanged )
+{
+NotifyControllerObservers( ECamEventMediaFileChanged );
+}
+PRINT( _L( "Camera <= CCamAppController::HandleSaveEvent" ) )
+}
+// ---------------------------------------------------------------------------
+// HandleViewfinderFrame
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleViewfinderFrame( TInt        /*aStatus*/,
+CFbsBitmap* /*aFrame*/ )
+{
+PRINT_FRQ( _L( "Camera => CCamAppController::HandleViewfinderFrame" ) );
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+// This function is called when a viewfinder bitmap arrives
+if( EPerfWaitingForStartup == iPerformanceState )
+{
+iPerformanceState = EPerfIdle;
+PERF_EVENT_END_L1( EPerfEventApplicationStartup );
+}
+else if( EPerfWaitingForStillMode == iPerformanceState )
+{
+iPerformanceState = EPerfIdle;
+PERF_EVENT_END_L1( EPerfEventSwitchToStillMode );
+}
+else if( EPerfWaitingForVideoMode == iPerformanceState )
+{
+iPerformanceState = EPerfIdle;
+PERF_EVENT_END_L1( EPerfEventSwitchToVideoMode );
+}
+else if( EPerfWaitingForBurstFrame == iPerformanceState )
+{
+iPerformanceState = EPerfIdle;
+PERF_EVENT_END_L1( EPerfEventBurstCaptureMomentToViewfinderFrame );
+}
+#endif
+if( ECamControllerVideo == iInfo.iMode )
+{
+// removed first vf frame usage as snapshot.
+// snapshot received now from Camera
+}
+else if( ECamControllerImage == iInfo.iMode )
+{
+// No need to duplicate here.
+}
+else
+{
+// Not valid state for vf frame.
+__ASSERT_DEBUG( EFalse, CamPanic( ECamPanicInvalidState ) );
+}
+if ( iZoomWaitingForCamera )
+{
+iZoomWaitingForCamera = EFalse;
+if ( iNewZoomPending )
+{
+SetZoomValue( iDesiredZoomVal );
+}
+}
+PRINT_FRQ( _L( "Camera <= CCamAppController::HandleViewfinderFrame" ) );
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandleSnapshotEvent( TInt aStatus,
+CFbsBitmap* aBitmap )
+{
+PRINT1( _L( "Camera => CCamAppController::HandleSnapshotEvent, status:%d" ), aStatus );
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+if( ECamImageCaptureBurst != iInfo.iImageMode )
+{
+// Do not log in burst mode
+PERF_EVENT_END_L1( EPerfEventShotToSnapshot );
+}
+else
+{
+// In burst mode
+PERF_MESSAGE_L2( EPerfMessageBurstSnapshotReady );
+}
+#endif
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_HANDLESNAPSHOTEVENT, "e_CAM_APP_SHOT_TO_SNAPSHOT 0" );    //CCORAPP_SHOT_TO_SNAPSHOT_END
+// ---------------------------------------------------------------------------
+// Video snapshot handling
+if( ECamControllerVideo == iInfo.iMode )
+{
+PRINT( _L("Camera <> Snapshot in video mode") );
+if( KErrNone == aStatus )
+{
+// Make a copy of the snapshot and set it as current video ss.
+CopySnapshotIfNeeded( *aBitmap, aStatus );
+if( iSnapShotCopy )
+{
+if (BurstCaptureArray()->Count() > 0 )
+{
+const CFbsBitmap* tempSnapShotCopy = iSnapShotCopy;
+TRAP_IGNORE( BurstCaptureArray()->ReplaceSnapshot( tempSnapShotCopy, 0 ) );
+}
+else
+{
+TRAP_IGNORE( BurstCaptureArray()->SetNextSnapshotL( *iSnapShotCopy ) );
+}
+}
+}
+// If video recording has already stopped, give snapshot event,
+// which causes snapshot to be updated in postcapture view.
+//
+// If recording is still in progress, the event would cause
+// too early switch to pastcapture.
+if( ECamNoOperation == iInfo.iOperation ||
+ECamCompleting == iInfo.iOperation )
+{
+NotifyControllerObservers( ECamEventSnapshotReady, aStatus );
+}
+return;
+}
+// ---------------------------------------------------------------------------
+// Still snapshot handling
+PRINT( _L("Camera <> Snapshot in still mode") );
+if( ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+// Update time lapse count during snapshot, so the update counter value
+// appears at the same time as snapshot.
+iTimeLapseCaptureCount++;
+NotifyControllerObservers( ECamEventCounterUpdated );
+}
+else if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+// Re-enable the screen saver if burst capture is completing.
+// This has to be done when all captures complete for timelapse.
+// EnableScreenSaver( ETrue );
+NotifyControllerObservers( ECamEventCounterUpdated );
+iUpdateFrozenFrame = ETrue;
+}
+// -------------------------------------------------------
+// if there is an error with the still capture operation
+if ( KErrNone != aStatus )
+{
+PRINT( _L("Camera <> CCamAppController: error in, cancel saving etc..") );
+// Store this now, as it's cleared by TidyCaptureArray
+// but needed a little later
+TBool wasCapturingBurst = (ECamImageCaptureBurst == iInfo.iImageMode);
+iImageSaveActive->Cancel();
+TidyCaptureArray( BurstCaptureArray()->NextFileIndex(), aStatus );
+PRINT( _L("Camera <> cancel further capturing") );
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestImageCancel ) );
+NotifyControllerObservers( ECamEventSnapshotReady, aStatus );
+if ( wasCapturingBurst )
+{
+// Need this here to allow the AppUi to update the state correctly
+// following the error condition.  This needs to be *after* the
+// change to OperationNone (called in TidyCaptureArray) so when the
+// AppUi forces CBA update we're not still in burst capture state.
+NotifyControllerObservers( ECamEventCaptureComplete, aStatus );
+}
+PRINT( _L( "Camera <> calling HandleCaptureCompletion()" ) )
+HandleCaptureCompletion();
+}
+// -------------------------------------------------------
+// No error reported
+else
+{
+PRINT( _L("Camera <> CCamAppController: status in KErrNone..") );
+__ASSERT_ALWAYS( aBitmap, CamPanic( ECamPanicNullPointer ) );
+CopySnapshotIfNeeded( *aBitmap, aStatus );
+// Removed filename reservation when snapshot arrives.
+// From now on, it's always done in HandleImageCaptureEvent,
+// even if snapshot comes first.
+// This is being ignored, but there is nothing to display in the app
+TRAP_IGNORE( BurstCaptureArray()->SetNextSnapshotL( *aBitmap ) )
+NotifyControllerObservers( ECamEventSnapshotReady );
+// If this is not a burst capture and snapshot came before image
+// data, then the operation is now entering the completion phase.
+// In case iFilenameReserved is set, imagedata has already
+// arrived and we don't need to change state here.
+if ( ECamCompleting != iInfo.iOperation &&
+ECamImageCaptureBurst != iInfo.iImageMode &&
+!iFilenameReserved )
+{
+SetOperation( ECamCompleting );
+}
+if( CurrentCapturedCount() < CaptureLimit() )
+{
+// Play capture sound for the next burst image
+PlaySound( CaptureToneId(), EFalse );
+}
+}
+// -------------------------------------------------------
+PRINT( _L( "Camera <= CCamAppController::HandleSnapshotEvent" ) );
+}
+// ---------------------------------------------------------------------------
+// HandleImageCaptureEventL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleImageCaptureEventL( TInt             aStatus,
+CCamBufferShare* aShare  )
+{
+PRINT1( _L("Camera => CCamAppController::HandleImageCaptureEventL, status:%d"), aStatus );
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+if( ECamImageCaptureBurst != iInfo.iImageMode )
+{
+// Do not log in burst mode
+PERF_EVENT_END_L1( EPerfEventShotToStillImageReady );
+}
+else
+{
+PERF_MESSAGE_L2( EPerfMessageBurstStillimageReady );
+}
+#endif // CAMERAAPP_PERFORMANCE_MEASUREMENT
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_HANDLEIMAGECAPTUREEVENTL, "e_CAM_APP_SHOT_TO_STILL 0" );  //CCORAPP_SHOT_TO_STILL_END
+/*
+// Check if we need to stop the burst capture.
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+if( CurrentCapturedCount() < CaptureLimit() )
+{
+// Play capture sound for the next burst image
+PlaySound( CaptureToneId(), EFalse );
+}
+}
+*/
+// If we have all the needed snapshots set the flag
+// so the processing image text is shown.
+// Do it here instead of handlesnapshotevent so that
+// the counter has time to show the last image as well
+if( CurrentCapturedCount() == CaptureLimit() )
+{
+iAllSnapshotsReceived = ETrue;
+}
+if( KErrNone == aStatus )
+{
+PRINT( _L("Camera <> CCamAppController: image capture status KErrNone") );
+aShare->Reserve();
+CleanupStack::PushL( TCleanupItem( CamBufferShareCleanup, aShare ) );
+// Reserve filename for saving the image. In case there's problem
+// with current media, switch to internal memory
+TRAPD(err, ReserveFileNamesL( iInfo.iMode, iInfo.iImageMode ) );
+if( KErrNone != err )
+{
+if( ECamMediaStorageCard == IntegerSettingValue( ECamSettingItemPhotoMediaStorage ) )
+{
+PRINT( _L("Camera <> Memory card access failed.") )
+NotifyControllerObservers( ECamEventInvalidMemoryCard );
+}
+// If we have got here, we can't access MMC. Switch to phone memory
+TRAP_IGNORE( ForceUsePhoneMemoryL() ); //with multiple drive support,
+//this actually uses the internal mass memory
+TRAPD(err, ReserveFileNamesL( iInfo.iMode, iInfo.iImageMode ) );
+if( KErrNone != err )
+{
+PRINT( _L("Camera <> Mass memory or phone memory access also failed.") )
+TRAP_IGNORE( ForceUsePhoneMemoryL() );
+TRAP_IGNORE( ReserveFileNamesL( iInfo.iMode, iInfo.iImageMode, ETrue ) );
+}
+}
+TBool markedForDelete = BurstCaptureArray()->IsNextImageDeleted();
+PRINT1( _L("Camera <> Next image delete mark:%d"), markedForDelete );
+if ( !markedForDelete )
+{
+PRINT( _L("Camera <> setting iImageSaveRequestPending to false"))
+iImageSaveRequestPending = EFalse;
+const TDesC& nextName( BurstCaptureArray()->NextFileName() );
+PRINT( _L("Camera <> BurstCaptureArray()->NextFileName() returned") );
+PRINT1( _L("Camera <> Set image to be saved, name:[%S]"), &nextName );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( ( iInfo.iImageMode == ECamImageCaptureSingle )
+&& ECamSettOff == IntegerSettingValue( ECamSettingItemShowCapturedPhoto )
+&& iInfo.iActiveCamera == ECamActiveCameraPrimary
+&& !appUi->IsEmbedded() )
+{
+HandleSaveEvent( ECamSaveEventStarted );
+}
+TBool added = iImageSaveActive->AddToSave( nextName, aShare );
+if ( !added )
+{
+PRINT( _L("Camera <> Image saving start unsuccessful!") );
+// The system state is consistent if this fails so ignore the error
+}
+else
+{
+PRINT( _L("Camera <> Image saving started ok.") );
+// Ownership of the data has now been passed to CCamImageSaveActive
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+NotifyControllerObservers( ECamEventImageData );
+}
+PRINT1( _L("Camera <> CCamAppController::HandleImageCaptureEventL array count:%d"), BurstCaptureArray()->Count() );
+// check if snapshot bitmap needs to be rotated before creating a thumbnail from it
+TBool rotate( ECamSettOn == iSettingsModel->IntegerSettingValue( ECamSettingItemImageRotation ) &&
+ECamSettOn == IntegerSettingValue( ECamSettingItemShowCapturedPhoto ) &&
+iCaptureOrientation != ECamOrientation0 &&
+iInfo.iActiveCamera == ECamActiveCameraPrimary );
+if ( ECamImageCaptureBurst != iInfo.iImageMode )
+{
+//create thumbnail or rotate first if needed
+if ( iConfigManager && iConfigManager->IsThumbnailManagerAPISupported() )
+{
+if ( rotate )
+{
+RotateSnapshotL();
+}
+else
+{
+TRAP_IGNORE( iImageSaveActive->CreateThumbnailsL( *BurstCaptureArray() ) );
+}
+}
+}
+}
+}
+CleanupStack::PopAndDestroy(); // aShare->Release()
+aShare = NULL;
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController: capture status *not* KErrNone, mark current file for delete") );
+DeleteCurrentFile();
+}
+iFilenameReserved = ETrue;
+PRINT( _L( "Camera <= CCamAppController::HandleImageCaptureEventL" ) );
+}
+// ---------------------------------------------------------------------------
+// HandleImageStopEventL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleImageStopEventL( TInt aStatus, TInt aFullCaptureCount )
+{
+PRINT2( _L("Camera => CCamAppController::HandleImageStopEventL, status:%d, full captures:%d"), aStatus, aFullCaptureCount );
+TBool saved = ( iImageSaveActive->Count()== 0 );
+switch( iInfo.iImageMode )
+{
+// -----------------------------------------------------
+case ECamImageCaptureBurst:
+{
+PRINT( _L( "Camera <> CCamAppController .. case ECamImageCaptureBurst" ) );
+// CompleteBurstOperation();
+// Re-enable screen saver
+EnableScreenSaver( ETrue );
+if( iBacklightTimer )
+{
+iBacklightTimer->Cancel();
+}
+TInt started( iCameraController->ControllerInfo().iSnapshotCount );
+if ( aFullCaptureCount < started )
+{
+PRINT ( _L("Camera <> CCamAppController .. [WARNING] Incomplete captures detected, cleaning up.." ) );
+PRINT1( _L("Camera <> CCamAppController .. [WARNING] snapshot     count: %d"), started );
+PRINT1( _L("Camera <> CCamAppController .. [WARNING] full capture count: %d"), aFullCaptureCount            );
+PRINT1( _L("Camera <> CCamAppController .. [WARNING] burst array  count: %d"), BurstCaptureArray()->Count() );
+TInt stopAt = Min( started, BurstCaptureArray()->Count() );
+for ( TInt index = aFullCaptureCount; index < stopAt; index++ )
+{
+PRINT1( _L("Camera <> CCamAppController .. [WARNING] deleting temp file from index %d.."), index );
+SetAsCurrentImage( index );
+// Parameter: notify about file system change only on last delete.
+DeleteCurrentFile( stopAt-1 == index );
+}
+PRINT1( _L("Camera <> CCamAppController .. [WARNING] setting as current image %d.."), aFullCaptureCount );
+SetAsCurrentImage( aFullCaptureCount );
+PRINT ( _L("Camera <> CCamAppController .. [WARNING] resetting burst array to required count..") );
+BurstCaptureArray()->Reset( aFullCaptureCount );
+}
+SetOperation( ECamCompleting );
+// We may have deleted all the images, so check the status here.
+if( iImageSaveActive->Count()== 0 )
+{
+PRINT( _L( "Camera <> CCamAppController .. images already saved, completing burst capture" ) )
+SetOperation( ECamNoOperation );
+NotifyControllerObservers( ECamEventCaptureComplete, aStatus );
+ReleaseArray();
+}
+// if no images were taken, clear AssumePostCaptureView flag
+if ( started == 0 )
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi )
+{
+appUi->SetAssumePostCaptureView( EFalse );
+}
+}
+break;
+}
+// -----------------------------------------------------
+case ECamImageCaptureSingle:
+{
+PRINT( _L( "Camera <> CCamAppController .. case ECamImageCaptureSingle" ) );
+// In secondary camera we can get snapshot as last event
+// so we might still be in capturing state.
+if( ECamCapturing == iInfo.iOperation )
+{
+PRINT( _L( "Camera <> CCamAppController .. still in capturing phase, set to completing first.." ) );
+SetOperation( ECamCompleting );
+}
+	  // In case of secondary camera, image may be saved before Stop event is received.
+	  // Notify capture complete event to the observers and other completion handling here.
+if( saved && ECamCompleting == iInfo.iOperation )
+{
+PRINT( _L( "Camera <> CCamAppController .. file saved, complete capture" ) );
+		// Operation mode is also set in HandleCaptureCompletion
+		HandleCaptureCompletion();
+		NotifyControllerObservers( ECamEventCaptureComplete, aStatus );
+ReleaseArray();
+}
+break;
+}
+// -----------------------------------------------------
+case ECamImageCaptureTimeLapse:
+{
+PRINT( _L( "Camera <> CCamAppController .. case ECamImageCaptureTimeLapse" ) );
+if( saved )
+{
+PRINT( _L( "Camera <> CCamAppController .. current file saved, complete this capture" ) );
+SetOperation( ECamNoOperation );
+ReleaseArray();
+}
+if ( iCompleteTimeLapsePending )
+{
+CompleteTimeLapseOperation();
+}
+else
+{
+// If the camera orientation changed during capture, set the new orientation in the engine
+// ready for the next timelapse capture
+if ( iConfigManager && iConfigManager->IsOrientationSensorSupported()
+		 && iOrientationChangeOccured )
+{
+iOrientationChangeOccured = EFalse;
+TRAP_IGNORE( SetImageOrientationL() );
+}
+}
+break;
+}
+// -----------------------------------------------------
+default:
+break;
+// -----------------------------------------------------
+}
+PRINT( _L( "Camera <= CCamAppController::HandleImageStopEventL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IdleTimeoutL
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::IdleTimeoutL( TAny* aPtr )
+{
+return static_cast<CCamAppController*>( aPtr )->DoIdleTimeoutL();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DoIdleTimeoutL
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::DoIdleTimeoutL()
+{
+// if a video recording has been paused for 60 seconds without key presses
+if ( ECamPaused == CurrentVideoOperation() )
+{
+NotifyControllerObservers( ECamEventVideoPauseTimeout, KErrNone );
+}
+// notify switch to standby mode and stop timer
+else if( ECamStandby != iInfo.iOperation && ECamTriActive == iCameraController->ViewfinderState())
+{
+SetOperation( ECamStandby );
+}
+else
+{
+// For Lint
+}
+iIdleTimer->Cancel();
+// Use backlight timer also with bitmap vf
+if( iBacklightTimer )
+{
+	if( ECamTriActive == iCameraController->ViewfinderState() )
+	  {
+	  User::ResetInactivityTime();
+}
+iBacklightTimer->Cancel();
+}
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StartIdleTimer
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StartIdleTimer()
+{
+PRINT( _L( "Camera => CCamAppController::StartIdleTimer" ) );
+// if in standby mode notify of switch back to pre-capture
+if ( ECamStandby == iInfo.iOperation )
+{
+PRINT( _L( "Camera <> CCamAppController::StartIdleTimer ECamStandby" ) );
+SetOperation( ECamNoOperation );
+}
+// if recording is in progress don't go to standby
+else if ( ECamCapturing == CurrentVideoOperation() )
+{
+PRINT( _L( "Camera <> CCamAppController::StartIdleTimer no restart" ) );
+// don't restart if recording operation in progress
+return;
+}
+// if recording is paused, use the idle timer to stop recording after 60 secs
+else
+{
+PRINT( _L( "Camera <> CCamAppController::StartIdleTimer else part" ) );
+// empty else statement to remove LINT error
+}
+// restart timer
+iIdleTimer->Cancel();
+// don't restart if capturing burst, setting time lapse or in a pretend exit state
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( !SequenceCaptureInProgress() && appUi && !appUi->IsInPretendExit()
+&& !appUi->TimeLapseSliderShown())
+{
+// restart timer
+PRINT( _L( "Camera <> CCamAppController::StartIdleTimer starting timer" ) );
+iIdleTimer->StartTimer();
+}
+if ( iDeepSleepTimer )
+{
+if ( iDeepSleepTimer->IsActive() )
+{
+PRINT( _L( "Camera <> CCamAppController::StartIdleTimer - restart deep sleep timer" ) );
+DeepSleepTimerCancel();
+DeepSleepTimerStart();
+}
+else if ( iDeepSleepTimerExpired )
+{
+iDeepSleepTimerExpired = EFalse; // clear flag
+TVwsViewId activeView;
+CCamAppUi* appUi =
+static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+(void) appUi->GetActiveViewId( activeView ); // ignore error
+if ( !IsViewFinding() && !InVideocallOrRinging() &&
+activeView.iViewUid.iUid != ECamViewIdVideoPostCapture &&
+activeView.iViewUid.iUid != ECamViewIdStillPostCapture &&
+activeView.iViewUid.iUid != ECamViewIdBurstThumbnail )
+{
+PRINT( _L( "Camera <> CCamAppController::StartIdleTimer - Deep sleep timer expired. Restart VF" ) );
+TCamCameraMode mode = CurrentMode() == ECamControllerVideo?
+ECamControllerVideo : ECamControllerImage;
+EnterViewfinderMode( mode );
+DeepSleepTimerStart();
+}
+}
+}
+PRINT( _L( "Camera <= CCamAppController::StartIdleTimer" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StopIdleTimer
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StopIdleTimer()
+{
+PRINT( _L( "Camera => CCamAppController::StopIdleTimer" ) );
+if( iIdleTimer )
+{
+iIdleTimer->Cancel();
+}
+PRINT( _L( "Camera <= CCamAppController::StopIdleTimer" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TimeLapseTimeoutL
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::TimeLapseTimeoutL( TAny* aPtr )
+{
+return static_cast<CCamAppController*>( aPtr )->DoTimeLapseTimeoutL();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DoTimeLapseTimeoutL
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::DoTimeLapseTimeoutL()
+{
+PRINT( _L("Camera => CCamAppController::DoTimeLapseTimeoutL" ))
+// Work out how much time is left before the next capture
+TTime now;
+now.HomeTime();
+TTimeIntervalMicroSeconds elapsedTime = now.MicroSecondsFrom( iTimeLapseStartTime );
+TInt64 remainingTime = iTimeLapseInterval.Int64() - elapsedTime.Int64();
+// update the remaining time countdown
+NotifyControllerObservers( ECamEventCounterUpdated );
+//if the total timelapse period has now completed
+if ( remainingTime <= 0 )
+{
+// Workaround for DoTimeLapseTimeoutL firing while in inappropriate state
+	// cause capture to be delayed by 1 sec
+	if( ECamNoOperation != iInfo.iOperation )
+		{
+		PRINT( _L("Camera <> CCamAppController::DoTimeLapseTimeoutL workaround" ))
+			//remainingTime = TInt64( KSecondInMicSec );
+		    iTimeLapseTimer->StartTimer();
+		}
+	else
+		{
+	    TInt remainingCount = ImagesRemaining( static_cast<TCamMediaStorage>( IntegerSettingValue( ECamSettingItemPhotoMediaStorage ) ), ETrue );
+	    if ( remainingCount > 0 )
+	      	{
+	      PRINT( _L("Camera => CCamAppController::DoTimeLapseTimeoutL about to do next capture" ))
+	      // About to do the next capture so decrement the view's usage count on the array
+	      ReleaseArray();
+if ( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+if( !CurrentSceneHasForcedFocus() )
+{
+if( !IsViewFinding() )
+{
+StartViewFinder();
+}
+StartAutoFocus();
+iCaptureRequested = ETrue; //Has to be set before focused/not focused event.
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController::DoTimeLapseTimeoutL capture with forcedfocus scene" ))
+Capture();
+}
+}
+else
+{
+	Capture();
+}
+			RestartTimeLapseTimerL();
+	}
+	    else
+	     {
+	     		PRINT( _L("Camera => CCamAppController::DoTimeLapseTimeoutL capture is complete" ))
+	      	CompleteTimeLapseOperation();
+	     }
+	   }
+return EFalse;
+}
+// Otherwise restart the timer for the next period
+else
+{
+if ( remainingTime < TInt64( KSecondInMicSec ) )
+{
+PRINT( _L("Camera => CCamAppController::DoTimeLapseTimeoutL shortening timer" ))
+iTimeLapseTimer->SetTimeout( (TInt)remainingTime );
+}
+else if(  ( remainingTime < TInt64( 5 *KSecondInMicSec )) && !iCameraWoken )
+	{
+		iCameraWoken = ETrue;
+		if( !IsViewFinding() )
+		{
+			StartViewFinder();
+		}
+		User::ResetInactivityTime();
+	}
+PRINT( _L("Camera => CCamAppController::DoTimeLapseTimeoutL restarting timer" ))
+iTimeLapseTimer->StartTimer();
+}
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SupportedFlashModes
+// Return flash modes supported engine
+// ---------------------------------------------------------------------------
+//
+TUint32 CCamAppController::SupportedFlashModes()
+{
+if( iCameraController )
+return iCameraController->CameraInfo().iFlashModesSupported;
+else
+return 0;
+//iSupportedFlashModes;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SupportedWBModes
+// Return white balance modes supported engine
+// ---------------------------------------------------------------------------
+//
+TUint32 CCamAppController::SupportedWBModes()
+{
+if( iCameraController )
+return iCameraController->CameraInfo().iWhiteBalanceModesSupported;
+else
+return 0;
+//iSupportedWBModes;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SupportedEVModes
+// Return EV modes supported engine
+// ---------------------------------------------------------------------------
+//
+TUint32 CCamAppController::SupportedEVModes()
+{
+if( iCameraController )
+return iCameraController->CameraInfo().iExposureModesSupported;
+else
+return 0;
+//iSupportedEVModes;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CaptureState
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::CaptureState()
+{
+if( iCameraController )
+{
+return iCameraController->ControllerInfo().iCaptureState;
+}
+else
+{
+return KErrNotFound;
+}
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::FlashStatus()
+// Returns pointer to FlashStatus object
+// -----------------------------------------------------------------------------
+//
+CCamFlashStatus*
+CCamAppController::FlashStatus() const
+{
+return iFlashStatus;
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::FlashRequired()
+//
+// -----------------------------------------------------------------------------
+//
+TBool
+CCamAppController::FlashRequired() const
+{
+if( ECamSceneSports == IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) )
+{
+// Flash is not required in sport scene, even if the flash mode
+// is forced or redeye.
+return EFalse;
+}
+// Make decision based on current flash mode
+TInt flashMode = IntegerSettingValue( ECamSettingItemDynamicPhotoFlash );
+switch( flashMode )
+{
+case ECamFlashOff:
+{
+return EFalse;
+}
+case ECamFlashAntiRedEye: // Flowthrough
+case ECamFlashForced:
+{
+return ETrue;
+}
+default:
+{
+// Just return true in the default case.
+// Automatic mode will decide if flash is used or not.
+return ETrue;
+}
+}
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::CheckFlash()
+//
+// -----------------------------------------------------------------------------
+//
+TBool
+CCamAppController::CheckFlash() const
+{
+PRINT ( _L("Camera => CCamAppController::CheckFlash") );
+PRINT1( _L("Camera <> CCamAppController:              flash required :%d  "), FlashRequired() );
+PRINT1( _L("Camera <> CCamAppController: FlashStatus: flash ready    :%d  "), iFlashStatus->FlashReady() );
+PRINT1( _L("Camera <> CCamAppController: CameraCtrl:  flash status   :[%s]"),
+KCamCameraReadyStateNames[iCameraController->FlashState()] );
+TBool ok( !FlashRequired() || iFlashStatus->FlashReady() );
+PRINT1( _L("Camera <= CCamAppController::CheckFlash, return:%d"), ok );
+#ifdef __WINSCW__
+return ETrue;
+#else
+return ok;
+#endif
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::SaveFlashMode()
+//
+// -----------------------------------------------------------------------------
+//
+void CCamAppController::SaveFlashMode()
+{
+iFlashModeSaved  = ETrue;
+iSavedFlashMode  = static_cast<TCamFlashId>( IntegerSettingValue( ECamSettingItemDynamicPhotoFlash ) );
+iSavedFlashScene = static_cast<TCamSceneId>( IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) );
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::RestoreFlashMode
+//
+// -----------------------------------------------------------------------------
+//
+void CCamAppController::RestoreFlashMode()
+{
+if( iFlashModeSaved )
+{
+if( iSavedFlashScene == IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) )
+{
+// Set saved flash mode
+TRAP_IGNORE( SetIntegerSettingValueL( ECamSettingItemDynamicPhotoFlash, iSavedFlashMode ) );
+}
+else
+{
+// Set default flash mode for this scene
+// SetDynamicSettingToDefault( ECamSettingItemDynamicPhotoFlash );
+TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );
+TInt sceneFlashMode = iSettingsModel->SceneSettingValue( scene, ECamSettingItemSceneFlashMode );
+TRAP_IGNORE( SetIntegerSettingValueL( ECamSettingItemDynamicPhotoFlash, sceneFlashMode ) );
+}
+}
+iFlashModeSaved = EFalse;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ForceUsePhoneMemoryL
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ForceUsePhoneMemoryL( TBool aEnable )
+	{
+	PRINT( _L("Camera => CCamAppController::ForceUsePhoneMemoryL") );
+	if( aEnable )
+		{
+		iForceUseOfPhoneMemory = ETrue;
+if( ExistMassStorage() )
+{
+// with multiple drives, the mass memory is the default
+PRINT( _L("Camera <> Force ECamMediaStorageMassStorage") );
+iForcedStorageLocation = ECamMediaStorageMassStorage;
+SetPathnamesToNewStorageL( ECamMediaStorageMassStorage );
+}
+else
+{
+PRINT( _L("Camera <> Force ECamMediaStoragePhone") );
+iForcedStorageLocation = ECamMediaStoragePhone;
+SetPathnamesToNewStorageL( ECamMediaStoragePhone );
+}
+		}
+	// Revert back to memory card, if aEnable is EFalse
+	else
+		{
+		iForceUseOfPhoneMemory = EFalse;
+iForcedStorageLocation = ECamMediaStorageNone;
+SetPathnamesToNewStorageL( iPreferredStorageLocation );
+		}
+	NotifyControllerObservers( ECamEventSaveLocationChanged );
+	PRINT( _L("Camera <= CCamAppController::ForceUsePhoneMemoryL") );
+	}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsPhoneMemoryForced
+// Check whether the use of phone memory is forced, because of unavailibility
+// or problems encountered in using MMC.
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsPhoneMemoryForced()
+	{
+	return iForceUseOfPhoneMemory;
+	}
+// ---------------------------------------------------------------------------
+// CCamAppController::CheckMemoryToUseL
+// Set the appropriate memory to use. Use Phone memory if MMC not available.
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::CheckMemoryToUseL()
+	{
+TInt key = ( ECamControllerImage == CurrentMode() )
+? ECamSettingItemPhotoMediaStorage
+: ECamSettingItemVideoMediaStorage;
+TCamMediaStorage storageLocation = static_cast<TCamMediaStorage> ( IntegerSettingValueUnfiltered(key) );
+TBool mmcAvailable = IsMemoryAvailable ( ECamMediaStorageCard );
+PRINT1( _L("Camera :: CCamAppController::CheckMemoryToUse preferred storage:%d"),
+storageLocation );
+// If MMC is preferred storage location but is not available
+	if ( storageLocation == ECamMediaStorageCard && !mmcAvailable )
+		{
+		PRINT( _L("Camera :: CCamAppController::CheckMemoryToUse - use phone memory / mass storage") )
+		ForceUsePhoneMemoryL( ETrue );
+		return ETrue;
+		}
+	// Preferred location is MMC and its available now -> stop forcing phone memory
+	else if( storageLocation == ECamMediaStorageCard && mmcAvailable &&
+	         iForceUseOfPhoneMemory )
+		{
+		PRINT( _L("Camera :: CCamAppController::CheckMemoryToUse - use MMC") )
+		ForceUsePhoneMemoryL( EFalse );
+		return ETrue;
+		}
+if ( storageLocation == ECamMediaStorageMassStorage && !ExistMassStorage() )
+		{
+		PRINT( _L("Camera :: CCamAppController::CheckMemoryToUse - no mass storage, use phone memory") )
+		ForceUsePhoneMemoryL( ETrue );
+		return ETrue;
+		}
+	// Mass storage is available now -> stop forcing phone memory
+	else if( storageLocation == ECamMediaStorageMassStorage && ExistMassStorage() && iForceUseOfPhoneMemory )
+		{
+		PRINT( _L("Camera :: CCamAppController::CheckMemoryToUse - use mass memory") )
+		ForceUsePhoneMemoryL( EFalse );
+		return ETrue;
+		}
+	else
+	  {
+	  SetPathnamesToNewStorageL( storageLocation );
+	  }
+return EFalse;
+	}
+// ---------------------------------------------------------------------------
+// CCamAppController::CompleteBurstOperation
+// Complete the burst operation
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CompleteBurstOperation()
+{
+PRINT( _L( "Camera => CCamAppController::CompleteBurstOperation" ) );
+iSequenceCaptureInProgress = EFalse;
+iNoBurstCancel=EFalse;
+if( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+PRINT1( _L("Camera <> CCamAppController::CompleteBurstOperation array count:%d"), BurstCaptureArray()->Count() );
+// Create thumbnails
+if( iConfigManager && iConfigManager->IsThumbnailManagerAPISupported() )
+{
+TRAP_IGNORE( iImageSaveActive->CreateThumbnailsL( *BurstCaptureArray() ) );
+}
+// Re-enable screen saver
+EnableScreenSaver( ETrue );
+	  if( iBacklightTimer )
+		{
+		iBacklightTimer->Cancel();
+		}
+SetOperation( ECamNoOperation );
+NotifyControllerObservers( ECamEventCaptureComplete, KErrNone );
+HandleCaptureCompletion();
+}
+PRINT( _L( "Camera <= CCamAppController::CompleteBurstOperation" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CompleteTimeLapseOperation
+// Complete the time lapse operation
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CompleteTimeLapseOperation()
+{
+PRINT( _L( "Camera => CCamAppController::CompleteTimeLapseOperation" ) );
+iSequenceCaptureInProgress = EFalse;
+if ( iTimeLapseTimer )
+{
+iTimeLapseTimer->Cancel();
+delete iTimeLapseTimer;
+iTimeLapseTimer = NULL;
+}
+if( ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+// Re-enable screen saver
+EnableScreenSaver( ETrue );
+iCompleteTimeLapsePending = EFalse;
+//      SetImageMode( ECamImageCaptureNone );
+SetOperation( ECamNoOperation      );
+NotifyControllerObservers( ECamEventCaptureComplete, KErrNone );
+HandleCaptureCompletion();
+iTimeLapseStartTime = TInt64( 0 );
+}
+PRINT( _L( "Camera <= CCamAppController::CompleteTimeLapseOperation" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::EngineProcessingCapture
+// Return whether or not the engine is carrying out a capture operation
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::EngineProcessingCapture() const
+{
+TBool engineIsProcessing = EFalse;
+if ( ECamCapturing  == iInfo.iOperation
+|| ECamPausing    == iInfo.iOperation
+|| ECamPaused     == iInfo.iOperation
+|| ECamResuming   == iInfo.iOperation
+|| ECamCompleting == iInfo.iOperation
+)
+{
+engineIsProcessing = ETrue;
+}
+return engineIsProcessing;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandleIncomingCall
+// Stop video recording (or burst capture in early stages)
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandleIncomingCall()
+{
+PRINT2( _L("Camera => CCamAppController::HandleIncomingCallL .. mode[%s] operation[%s]"),
+KCamModeNames[iInfo.iMode],
+KCamCaptureOperationNames[iInfo.iOperation]
+);
+if( ECamControllerVideo == iInfo.iMode )
+{
+// if video is recording or paused
+if ( !iSaving
+&& ( ECamCapturing == iInfo.iOperation
+|| ECamPaused    == iInfo.iOperation ) )
+{
+StopVideoRecording();
+}
+}
+else if( ECamControllerImage == iInfo.iMode )
+{
+iCaptureRequested = EFalse;
+switch( iInfo.iImageMode )
+{
+// if a timelapse operation is in progress
+case ECamImageCaptureTimeLapse:
+{
+TRAP_IGNORE( StopSequenceCaptureL() );
+break;
+}
+case ECamImageCaptureBurst:
+{
+TRAP_IGNORE( SoftStopBurstL( ETrue ) );
+/*
+if ( ECamCompleting == iInfo.iOperation )
+{
+// if some of the image captures failed
+// release the reserved filenames and tidy the array
+TInt captured( iCameraController->ControllerInfo().iCaptureCount );
+if ( BurstCaptureArray()->NextFileIndex() < captured )
+{
+TInt index;
+TInt stopAt = Min( captured, BurstCaptureArray()->Count() );
+for ( index = BurstCaptureArray()->NextFileIndex(); index < stopAt; index++ )
+{
+SetAsCurrentImage( index );
+DeleteCurrentFile();
+}
+SetAsCurrentImage( 0 );
+BurstCaptureArray()->Reset( BurstCaptureArray()->NextFileIndex() );
+// Finished with this now
+}
+//          SetImageMode( ECamImageCaptureNone );
+if( iImageSaveActive )
+iImageSaveActive->DismissProgressNote();
+StartIdleTimer();
+}
+*/
+break;
+}
+default:
+break;
+}
+}
+else
+{
+// no action needed
+}
+PRINT( _L( "Camera <= CCamAppController::HandleIncomingCallL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::FileSize
+// Returns the file size of the specified captured item, or KErrNotFound if doesn't exist
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::FileSize( TDesC& aFilename ) const
+{
+return iImageSaveActive->FileSize( aFilename );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CancelStillCaptureNow
+// Immediately cancels an ongoing still capture
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CancelStillCaptureNow()
+{
+PRINT( _L( "Camera => CCamAppController::CancelStillCaptureNow" ) )
+// Re-enable screen saver
+EnableScreenSaver( ETrue );
+//    iEngine->CancelCaptureStill();
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestImageCancel ) );
+// ensure that any outstanding images are discarded
+SetOperation( ECamCompleting  );
+SetOperation( ECamNoOperation );
+// If sequence mode, remove items from the array
+// this prevents the post capture view from showing
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+BurstCaptureArray()->Reset( 0 );
+}
+else // single capture, the array is no longer needed
+{
+PRINT( _L( "Camera <> single capture so releasing array and starting vf" ) )
+ReleaseArray();
+FreezeViewFinder( EFalse );
+}
+// Cancel any pending saves, this will call CompleteBurstOperation for sequence
+PRINT( _L( "Camera <> calling iImageSaveArray->Cancel" ) )
+iImageSaveActive->Cancel();
+PRINT( _L( "Camera <= CCamAppController::CancelStillCaptureNow" ) )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TidyCaptureArray
+// Tidy up capture array in event of burst capture failure
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::TidyCaptureArray( TInt aImageCountDelivered,
+TInt /*aError*/               )
+{
+PRINT1( _L("Camera => CCamAppController::TidyCaptureArray img count %d"), aImageCountDelivered )
+iSoundPlayer->EnableAllKeySounds();
+// if some of the image captures failed
+// release the reserved filenames and tidy the array
+TInt captured( iCameraController->ControllerInfo().iSnapshotCount );
+if ( aImageCountDelivered < captured )
+{
+TInt index;
+TInt stopAt = Min( captured, BurstCaptureArray()->Count() );
+for ( index = aImageCountDelivered; index < stopAt; index++ )
+{
+PRINT1( _L("Camera <> TidyCaptureArray delete current %d"),index )
+SetAsCurrentImage( index );
+DeleteCurrentFile();
+}
+SetAsCurrentImage( 0 );
+iCaptureArray->Reset( aImageCountDelivered );
+// Finished with this now
+}
+SetImageMode( ECamImageCaptureNone );
+StartIdleTimer();
+// Need to release the array
+ReleaseArray();
+// Unfreeze the viewfinder
+FreezeViewFinder( EFalse );
+// Change op state to none
+SetOperation( ECamNoOperation );
+PRINT( _L("Camera <= CCamAppController::TidyCaptureArray") )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CaptureToneId
+// Returns the current capture tone
+//
+// ---------------------------------------------------------------------------
+//
+TCamSoundId CCamAppController::CaptureToneId( )
+{
+TCamSoundId toneId = ECamStillCaptureSoundId1;
+switch(iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoCaptureTone ) )
+{
+case ECamSettTone1:
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+toneId = ECamBurstCaptureSoundId1;
+}
+else
+{
+toneId = ECamStillCaptureSoundId1;
+}
+break;
+case ECamSettTone2:
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+toneId = ECamBurstCaptureSoundId2;
+}
+else
+{
+toneId = ECamStillCaptureSoundId2;
+}
+break;
+case ECamSettTone3:
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+toneId = ECamBurstCaptureSoundId3;
+}
+else
+{
+toneId = ECamStillCaptureSoundId3;
+}
+break;
+case ECamSettTone4:
+if ( ECamImageCaptureBurst == iInfo.iImageMode )
+{
+toneId = ECamBurstCaptureSoundId4;
+}
+else
+{
+toneId = ECamStillCaptureSoundId4;
+}
+break;
+default:
+break;
+}
+return toneId;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::LoadSecondaryCameraSettingsL()
+// Update settings for secondary camera
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::LoadSecondaryCameraSettingsL()
+{
+OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMAPPCONTROLLER_LOADSECONDARYCAMERASETTINGSL, "e_CCamAppController_LoadSecondaryCameraSettingsL 1" );
+PRINT( _L("Camera => CCamAppController::LoadSecondaryCameraSettingsL" ))
+iSettingsModel->StorePrimaryCameraSettingsL();
+PRINT( _L("Camera <> CCamAppController::LoadSecondaryCameraSettingsL B" ))
+SetIntegerSettingValueL( ECamSettingItemPhotoQuality,
+iConfiguration->SecondaryCameraImageQuality() );
+PRINT(  _L("Camera <> CCamAppController::LoadSecondaryCameraSettingsL C" ))
+SetIntegerSettingValueL( ECamSettingItemVideoQuality,
+iConfiguration->SecondaryCameraVideoQuality() );
+PRINT( _L("Camera <> CCamAppController::LoadSecondaryCameraSettingsL E" ))
+SetIntegerSettingValueL( ECamSettingItemDynamicPhotoScene, ECamSceneAuto );
+SetIntegerSettingValueL( ECamSettingItemDynamicVideoScene, ECamSceneNormal );
+PRINT( _L("Camera <> CCamAppController::LoadSecondaryCameraSettingsL F" ))
+PRINT( _L("Camera <= CCamAppController::LoadSecondaryCameraSettingsL" ))
+OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMAPPCONTROLLER_LOADSECONDARYCAMERASETTINGSL, "e_CCamAppController_LoadSecondaryCameraSettingsL 0" );
+}
+// ---------------------------------------------------------------------------
+// ImageOrientation <<public>>
+//
+// Return the current image orientation based on data from orientation sensor.
+// If "image rotation" setting is OFF, the value has been overriden with
+// "no rotation" value (ECamOrientation0).
+//
+// Provided (primarily) for Camera Controller even if orientation
+// sensor is not supported. In that case the returned
+// value is always ECamOrientation0.
+// ---------------------------------------------------------------------------
+//
+TCamImageOrientation
+CCamAppController::ImageOrientation() const
+{
+return iImageOrientation;
+}
+// ---------------------------------------------------------------------------
+// Indicates data is available in the receiving buffer. A client can read
+// the data through GetData()-function in the related channel object. Data
+// is valid until the data received notification occurs again.
+//
+// @param[in] aChannel Reference to the related channel object
+// @param[in] aCount Data object count in receiving buffer. Not used in this implementation.
+// @param[in] aDataLost Number of lost data items. Not used in this implementation. It does not
+//     matter if some data event is lost.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DataReceived( CSensrvChannel& aChannel,
+TInt aCount,
+TInt aDataLost )
+{
+PRINT3( _L("Camera => CCamAppController::DataReceived aChannel %d aCount %d aDataLost %d"),
+aChannel.GetChannelInfo().iChannelType, aCount, aDataLost );
+if ( KSensrvChannelTypeIdOrientationData == aChannel.GetChannelInfo().iChannelType )
+{
+TBool rotate( ECamSettOn == iSettingsModel->IntegerSettingValue( ECamSettingItemImageRotation ) );
+if( rotate )
+{
+TSensrvOrientationData orientationData;
+TPckg<TSensrvOrientationData> orientationPackage( orientationData );
+aChannel.GetData( orientationPackage );
+iImageOrientation =
+MapSensorOrientatio2CamOrientation( orientationData.iDeviceOrientation, iLastImageOrientation );
+}
+else
+{
+// If "rotate images" setting is OFF, set "no rotation" value
+iImageOrientation = ECamOrientation0;
+}
+// rotate image if we are in still capture mode but not currently
+// capturing image, no rotation in burst mode or if orientation has stayed the same
+if( IsFlagOn( CameraControllerState(), ECamImageOn ) &&
+rotate &&
+iLastImageOrientation != iImageOrientation &&
+iImageOrientation != ECamOrientationIgnore)
+{
+if( ECamCapturing   != CurrentOperation() &&
+ECamFocusing    != CurrentOperation() &&
+ECamFocused     != CurrentOperation() &&
+ECamFocusFailed != CurrentOperation() &&
+ECamCompleting  != CurrentOperation() &&
+ECamImageCaptureBurst != iInfo.iImageMode &&
+ECamImageCaptureBurst != iInfo.iTargetImageMode )
+{
+PRINT( _L("Camera <> CCamAppController:DataReceived calling SetImageOrientationL()") );
+TRAP_IGNORE( SetImageOrientationL() );
+}
+else
+{
+// queue a request to re-prepare still capture
+PRINT( _L("Camera <> CCamAppController: Queueing an orientation change event") );
+iOrientationChangeOccured = ETrue;
+}
+}
+else
+{
+iOrientationChangeOccured = EFalse;
+}
+if( iImageOrientation != ECamOrientationIgnore )
+{
+iLastImageOrientation = iImageOrientation;
+}
+}
+PRINT ( _L("Camera <= CCamAppController::DataReceived") );
+}
+// ---------------------------------------------------------------------------
+// Data listening failed.
+// If error was fatal, channel has also been closed and sensor server session
+// terminated. If error was minor, some data has potentially been lost.
+// iAccSensorChannel needs to be closed in fatal error case. A new channel will
+// be created the next time we call UpdateSensorApiL().
+//
+// @param[in] aChannel Reference to the related channel object
+// @param[in] aError Error code.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DataError( CSensrvChannel& aChannel,
+TSensrvErrorSeverity aError )
+{
+PRINT2( _L("Camera => CCamAppController::DataError aChannel %d aError %d"), aChannel.GetChannelInfo().iChannelType, aError );
+if ( ESensrvErrorSeverityFatal == aError )
+{
+// Delete sensor api object
+delete iAccSensorChannel;
+iAccSensorChannel = NULL;
+iAccSensorListening = EFalse;
+// Set orientation back to default if not already there.
+iImageOrientation   = ECamOrientation0;
+}
+}
+// ---------------------------------------------------------------------------
+// Returns a pointer to a specified interface
+//
+// @since S60 5.0
+// @param aInterfaceUid Identifier of the interface to be retrieved
+// @param aInterface A reference to a pointer that retrieves the specified interface.
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::GetDataListenerInterfaceL( TUid aInterfaceUid,
+TAny*& aInterface )
+{
+aInterface = NULL;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetImageOrientationL()
+// Setup image rotation parameters
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetImageOrientationL()
+{
+PRINT( _L("Camera => CCamAppController::SetImageOrientationL") );
+if( iConfigManager && iConfigManager->IsOrientationSensorSupported()
+		&& iCameraController )
+{
+if ( ECamActiveCameraPrimary == iInfo.iActiveCamera )
+{
+// Camera controller asks for the current orientation through
+// our ImageOrientation(). Value for that was updated in
+// DataReceived() callback.
+iCameraController->DirectSettingsChangeL( ECameraSettingOrientation );
+}
+else
+{
+// No action in secondary camera.
+}
+}
+PRINT( _L("Camera <= CCamAppController::SetImageOrientationL"))
+}
+// ---------------------------------------------------------------------------
+// MapSensorOrientatio2CamOrientation
+// ---------------------------------------------------------------------------
+//
+TCamImageOrientation
+CCamAppController::MapSensorOrientatio2CamOrientation(
+const TSensrvOrientationData::TSensrvDeviceOrientation& aSensorOrientation, TCamImageOrientation aLastImageOrientation )
+{
+PRINT1 ( _L("Camera => CCamAppController::MapSensorOrientatio2CamOrientation aSensorOrientation: %d"), aSensorOrientation );
+TCamImageOrientation cameraOrientation( ECamOrientation0 );
+switch( aSensorOrientation )
+{
+case TSensrvOrientationData::EOrientationDisplayUpwards:
+// If coming from upside down portrait...
+if ( ECamOrientation270 == aLastImageOrientation )
+{
+	// Switch from upside down portrait to normal portrait.") )
+cameraOrientation = ECamOrientation90; // Set normal portrait
+}
+// If coming from upside down landscape...
+else if ( ECamOrientation180 == aLastImageOrientation )
+{
+	// Switch from upside down landscape to normal landscape...") )
+cameraOrientation = ECamOrientation0; // Set normal lanscape
+}
+// If neither one, keep the current image orientation.
+else
+{
+cameraOrientation = ECamOrientationIgnore;
+}
+break;
+case TSensrvOrientationData::EOrientationDisplayDownwards:
+	  // Camera is pointing up now. Check if it was upside down previously.
+// If coming from upside down portrait...
+if ( ECamOrientation270 == aLastImageOrientation )
+{
+	// Switch from upside down portrait to normal portrait...") )
+cameraOrientation = ECamOrientation90; // Set normal portrait
+}
+// If coming from upside down landscape...
+else if ( ECamOrientation180 == aLastImageOrientation )
+{
+	// Switch from upside down landscape to normal landscape...") )
+cameraOrientation = ECamOrientation0; // Set normal lanscape
+}
+// If neither one, keep the current image orientation.
+else
+{
+cameraOrientation = ECamOrientationIgnore;
+}
+	  break;
+case TSensrvOrientationData::EOrientationDisplayRightUp:
+case TSensrvOrientationData::EOrientationUndefined:
+cameraOrientation = ECamOrientation0;
+break;
+case TSensrvOrientationData::EOrientationDisplayUp:
+cameraOrientation = ECamOrientation90;
+break;
+case TSensrvOrientationData::EOrientationDisplayLeftUp:
+cameraOrientation = ECamOrientation180;
+break;
+case TSensrvOrientationData::EOrientationDisplayDown:
+cameraOrientation = ECamOrientation270;
+break;
+default:
+PRINT( _L("Camera <> Unexpected orientation value") );
+break;
+}
+PRINT1( _L("Camera <= CCamAppController::MapSensorOrientatio2CamOrientation, return [%s]"),
+KCamOrientationNames[cameraOrientation] );
+return cameraOrientation;
+}
+// ---------------------------------------------------------------------------
+// MapSensorOrientatio2CamOrientation
+// ---------------------------------------------------------------------------
+//
+CBitmapRotator::TRotationAngle
+CCamAppController::MapCamOrientation2RotationAngle(
+const TCamImageOrientation aOrientation )
+{
+PRINT1 ( _L("Camera => CCamAppController::MapCamOrientation2RotationAngle aOrientation: %d"), aOrientation );
+CBitmapRotator::TRotationAngle angle;
+switch( aOrientation )
+{
+case ECamOrientation90:
+angle = CBitmapRotator::ERotation90DegreesClockwise;
+break;
+case ECamOrientation180:
+angle = CBitmapRotator::ERotation180DegreesClockwise;
+break;
+case ECamOrientation270:
+angle = CBitmapRotator::ERotation270DegreesClockwise;
+break;
+default:
+PRINT( _L("Camera <> Unexpected orientation value") );
+// using a value to avoid compiler warning
+angle = CBitmapRotator::ERotation90DegreesClockwise;
+break;
+}
+PRINT1( _L("Camera <= CCamAppController::MapCamOrientation2RotationAngle, return %d"), angle );
+return angle;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::UpdateSensorApiL() <<public>>
+// Updates the sensorApi object when the app focus changes
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::UpdateSensorApiL(TBool aStartupApi)
+{
+PRINT(_L("Camera => CCamAppController::UpdateSensorApiL"));
+if( iConfigManager && iConfigManager->IsOrientationSensorSupported() )
+	{
+	    if(aStartupApi)
+	        {
+	        // only activate the orientation channel for image mode
+	        if( ECamControllerImage == CurrentMode() )
+	          {
+	        // This if-statement intentionally not a condition of the first if.
+	        // If the iAccSensorChannel is already active, we don't want to recreate it
+	        // and leak memory, but at the same time, we don't want to destroy it either.
+	        if( !iAccSensorChannel )
+	            {
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - Starting new sensor channel api - info not yet initialized"));
+	            //Construct a channel finder.
+	            CSensrvChannelFinder* channelFinder;
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - calling CSensrvChannelFinder::NewL()"));
+	            //CSensorChannelFinder* channelFinder;
+	            channelFinder = CSensrvChannelFinder::NewL();
+	            //channelFinder = CSensorChannelFinder::NewL();
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - CSensrvChannelFinder::NewL() returned without a leave"));
+	            CleanupStack::PushL( channelFinder );
+	            //List of found channels.
+	            RSensrvChannelInfoList channelInfoList;
+	            CleanupClosePushL( channelInfoList );
+	            //Create and fill channel search criteria.
+	            TSensrvChannelInfo channelInfo;
+	            channelInfo.iChannelType = KSensrvChannelTypeIdOrientationData;
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - calling channelFinder->FindChannelsL"));
+	            //Find the orientation channel
+	            channelFinder->FindChannelsL( channelInfoList, channelInfo );
+	            if( channelInfoList.Count() != 1 )
+	                {
+	                //The device doesn’t support orientation data channel or
+	                //there are several orientation channels.
+	                PRINT1(_L("Camera <=> CCamAppController::UpdateSensorApiL - The device doesn’t support orientation data channel or there are several orientation channels: %d channels found"),channelInfoList.Count());
+	                User::Leave( KErrNotSupported );
+	                }
+	            else
+	                {
+	                //orientation channel found
+	                PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - orientation channel found"));
+	                }
+	            //Open the orientation channel.
+	            //When the channel object is created the channel info object
+	            //must be an object returned by CSensrvChannelFinder::FindChannelsL().
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - calling CSensrvChannel::NewL"));
+	            iAccSensorChannel = CSensrvChannel::NewL( channelInfoList[ 0 ] );
+	            //iAccSensorChannel = CSensorChannel::NewL( channelInfoList[ 0 ] );
+	            //CleanupStack::PushL( iAccSensorChannel );
+	            CleanupStack::PopAndDestroy( &channelInfoList ); //Close() is being called on "channelInfoList"
+	            CleanupStack::PopAndDestroy( channelFinder );
+	          }
+	        if( !iAccSensorListening )
+	            {
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - calling iAccSensorChannel->OpenChannelL()"));
+	            TRAPD(channelerror, iAccSensorChannel->OpenChannelL() );
+	            if (channelerror!=KErrNone)
+	                {
+	                PRINT1(_L("CCamAppController::UpdateSensorApiL - iAccSensorChannel->OpenChannelL() failed. Error code: %d"),channelerror);
+	                User::Leave( channelerror );
+	                }
+	            //iAccSensorChannel->OpenChannelL();
+	            //orientation channel is now open.
+	            // start listening
+	            PRINT(_L("Camera <=> CCamAppController::UpdateSensorApiL - calling iAccSensorChannel->StartDataListeningL"));
+	            iAccSensorChannel->StartDataListeningL( this, //this object is data listener for this channel
+	                                                   1, //aDesiredCount is one, i.e. each orientation change is notified separately
+	                                                   1, //aMaximumCount is one, i.e. object count in receiving data buffer is one
+	                                                   0 );//buffering period is not used
+	            iAccSensorListening = ETrue;
+	            iLastImageOrientation = ECamOrientation0;
+	            }
+	          }
+	        }
+	    else // shut down the sensorApi object
+	        {
+	        PRINT(_L("Camera <=> UpdateSensorApiL shutting down iAccSensor"))
+	        if(iAccSensorListening)
+	            {
+	            // Stop listening to the events
+	            iAccSensorChannel->StopDataListening();
+	            iAccSensorListening = EFalse;
+	            }
+	        // Delete sensor api object
+	        delete iAccSensorChannel;
+	        iAccSensorChannel = NULL;
+	        }
+}
+PRINT(_L("Camera <= CCamAppController::UpdateSensorApiL"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandlePropertyChangedL()
+// Handle changes in specified property
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandlePropertyChangedL( const TUid& aCategory, const TUint aKey )
+{
+PRINT( _L("Camera => CCamAppController::HandlePropertyChangedL"))
+#if !( defined(__WINS__) || defined(__WINSCW__) )
+if ( iConfigManager && iConfigManager->IsLensCoverSupported() )
+{
+// First if condition could be removed after PCFW has released
+// creation for KLensCoverStatus key
+if ( ( aCategory == NMusResourceApi::KCategoryUid &&
+aKey == NMusResourceApi::KCameraAvailability ) ||
+( aCategory == CameraPlatPSKeys::KPSCameraPlatUid &&
+aKey == CameraPlatPSKeys::KLensCoverStatus ) )
+{
+TInt err = iSlideStateWatcher->Get( iNewSlideState );
+PRINT2( _L( "Camera HandlePropertyChangedL getting slider state = %d, err = %d" ), iNewSlideState, err )
+if ( iNewSlideState != iSlideState  )
+{
+delete iSliderCallBack;
+iSliderCallBack = NULL;
+iSliderCallBack = CPeriodic::NewL( CActive::EPriorityIdle );
+iSliderCallBack->Start( KLensCoverDelay, KLensCoverDelay, TCallBack( LensCoverUpdateL, this ) );
+}
+}
+else
+{
+(void)aCategory;
+(void)aKey;
+}
+}
+#endif // !( defined(__WINS__) || defined(__WINSCW__
+PRINT( _L("Camera <= CCamAppController::HandlePropertyChangedL"))
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::LensCoverUpdate()
+// Callback function that is called when lens cover state changes.
+// Used to implement delayed handling of lens cover events.
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::LensCoverUpdateL( TAny* aPtr )
+{
+PRINT( _L( "Camera => CCamAppController::LensCoverUpdateL()" ) )
+CCamAppController* self = static_cast<CCamAppController*>( aPtr );
+if ( self->iNewSlideState != self->iSlideState ||
+self->iNewSlideState == CameraPlatPSKeys::EClosed // always handle closing
+)
+{
+self->iSlideState = self->iNewSlideState;
+if ( self->iSlideState == CameraPlatPSKeys::EClosed )
+{
+PRINT( _L( "Camera => CCamAppController::LensCoverUpdateL() SLIDE CLOSED" ) )
+self->HandleSlideClosedL();
+}
+else if ( self->iSlideState == CameraPlatPSKeys::EOpen )
+{
+PRINT( _L( "Camera => CCamAppController::LensCoverUpdateL() SLIDE OPENED" ) )
+self->HandleSlideOpenedL();
+}
+}
+self->iSliderCallBack->Cancel();
+delete self->iSliderCallBack;
+self->iSliderCallBack = 0;
+PRINT( _L( "Camera <= CCamAppController::LensCoverUpdateL()" ) )
+return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RefreshSlideState
+// Force a refresh of the slide status
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::RefreshSlideStatus()
+{
+PRINT( _L("Camera => CCamAppController::RefreshSlideStatus") );
+// read the slider status from P & S key
+if ( iSlideStateWatcher->Get( iSlideState ) != KErrNone )
+{
+iSlideState = KErrNone;
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandleSlideClosedL
+// Handle the slide closed event
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandleSlideClosedL()
+{
+PRINT( _L("Camera => CCamAppController::HandleSlideClosedL") );
+NotifyControllerObservers( ECamEventSliderClosed );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( appUi->IsInPretendExit() )
+{
+PRINT( _L("Camera <= CCamAppController::HandleSlideClosedL already in pretend exit") );
+return;
+}
+SetCameraSwitchRequired( ESwitchDone );
+// shutdown the camera on slide closing if EDGE variant/standalone app
+// don't close app if embedded or embedding
+TInt camerasAvailable = CamerasAvailable();
+TVwsViewId activeView;
+TInt viewErr = appUi->GetActiveViewId( activeView );
+TBool embedded = appUi->IsEmbedded();
+TBool embedding = appUi->Embedding();
+if ( camerasAvailable == 1 ) // EDGE variant
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - camerasAvailable == 1") );
+// if embedding another app then don't exit just yet
+if ( embedding )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - Embedding mode") );
+// remember that the slider has been closed
+iSliderCloseEvent = ETrue;
+}
+// Embedded post capture view
+else if ( embedded && viewErr == KErrNone &&
+( activeView.iViewUid.iUid == ECamViewIdStillPostCapture ||
+activeView.iViewUid.iUid == ECamViewIdVideoPostCapture ) )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - Embedded post capture") );
+// remember that the slider has been closed
+iSliderCloseEvent = ETrue;
+}
+// if standalone app performing a burst capture,
+// don't exit till complete
+else if ( ECamImageCaptureBurst == iInfo.iImageMode ||
+ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+// remember that the slider has been closed
+iSliderCloseEvent = ETrue;
+StopSequenceCaptureL();
+}
+else // standalone or embedded pre capture view
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - emit ECamCmdSlideClosedExit") );
+appUi->HandleCommandL( ECamCmdSlideClosedExit );
+}
+}
+else // variants with > 1 camera
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - camerasAvailable > 1") );
+if ( !embedding && !embedded )
+{
+// if standalone app performing a burst capture,
+// don't exit till complete
+if ( ECamImageCaptureBurst == iInfo.iImageMode ||
+ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+// remember that the slider has been closed
+iSliderCloseEvent = ETrue;
+StopSequenceCaptureL();
+}
+else
+{
+PRINT( _L("Camera Normal mode-handle ECamCmdSlideClosedExit") );
+appUi->SetLensCoverExit( ETrue );
+if ( ECamViewIdVideoPreCapture == activeView.iViewUid.iUid )
+{
+// stop recording and save the video
+StopVideoRecording();
+}
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - emit ECamCmdSlideClosedExit") );
+appUi->HandleCommandL( ECamCmdSlideClosedExit );
+				// 2ndary camera, slider closed -> application to be closed,
+				// not in embedded mode
+if ( iInfo.iActiveCamera == ECamActiveCameraSecondary )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - 2ndary camera slider closed, app closing...") );
+appUi->CloseAppL();
+}
+}
+}
+else // we are embedded in an app or embedding another app
+{
+// remember that the slider has been closed
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - Embedded/Embedding mode") );
+if ( viewErr == KErrNone )
+{
+iSliderCloseEvent = ETrue;
+PRINT1( _L("Camera <> CCamAppController::HandleSlideClosedL - active view %d"), activeView.iViewUid.iUid );
+PRINT1( _L("Camera <> CCamAppController::HandleSlideClosedL - iInfo.iOperation %d"), iInfo.iOperation );
+// switch the camera if slide is closed and primary camera
+// is active in embedded mode
+switch ( activeView.iViewUid.iUid )
+{
+case ECamViewIdStillPreCapture:
+case ECamViewIdVideoPreCapture:
+{
+// if in pre capture view and slide is closed
+if ( iInfo.iActiveCamera == ECamActiveCameraPrimary )
+{
+if ( iInfo.iOperation != ECamPaused &&
+iInfo.iOperation != ECamCapturing &&
+iInfo.iOperation != ECamCompleting &&
+iInfo.iOperation != ECamPausing &&
+iInfo.iOperation != ECamResuming &&
+!iVideoRequested )
+{
+appUi->HandleCommandL( ECamCmdSwitchCamera );
+}
+else if ( iInfo.iOperation == ECamCapturing ||
+iInfo.iOperation == ECamPaused )
+{
+StopVideoRecording();
+}
+else if ( iVideoRequested )
+{
+StopVideoRecording();
+// cancel any outstanding sound requests
+iSoundPlayer->CancelAllPlaying();
+appUi->HandleCommandL( ECamCmdSwitchCamera );
+}
+else // lint
+{
+}
+}
+else
+{
+// Embedded camera not closed even if lens cover is closed.
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - 2ndary camera, no action..") );
+}
+}
+break;
+case ECamViewIdStillPostCapture:
+case ECamViewIdVideoPostCapture:
+{
+// Embedded camera not closed even if lens cover is closed.
+}
+break;
+default:
+break;
+}
+}
+else if ( viewErr == KErrNotFound  )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - view not found") );
+if ( ECamActiveCameraPrimary == iInfo.iActiveCamera )
+{
+PRINT( _L("Camera <> CCamAppController::HandleSlideClosedL - need switch to 2ndary") );
+SetCameraSwitchRequired( ESwitchPrimaryToSecondary );
+if ( !appUi->AppInBackground( ETrue ) )
+{
+appUi->HandleCommandL( ECamCmdSwitchCamera );
+}
+}
+}
+}
+}
+PRINT( _L("Camera <= CCamAppController::HandleSlideClosedL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandleSlideOpenedL
+// Handles the slide opened event
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandleSlideOpenedL()
+{
+PRINT( _L("Camera => CCamAppController::HandleSlideOpenedL") );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// reset slider event flag
+if ( iSliderCloseEvent )
+{
+iSliderCloseEvent = EFalse;
+}
+TVwsViewId activeView;
+TInt viewErr = appUi->GetActiveViewId( activeView );
+if ( viewErr == KErrNone )
+{
+PRINT1( _L("Camera HandleSlideOpenedL => active view %d"),
+activeView.iViewUid.iUid );
+// For EDGE variant
+TInt camerasAvailable = CamerasAvailable();
+if ( camerasAvailable == 1 )
+{
+// if in standby view and the slide is opened then exit standby view
+if ( iInfo.iOperation == ECamStandby )
+{
+PRINT( _L("Camera HandleSlideOpenedL => Exit Standby view") );
+appUi->View( activeView.iViewUid )->HandleCommandL(
+ECamCmdExitStandby );
+}
+}
+else // variants with > 1 camera
+{
+PRINT1( _L("Camera HandleSlideOpenedL => iInfo.iOperation %d"),
+iInfo.iOperation );
+PRINT1( _L("Camera HandleSlideOpenedL => CameraState() %d"),
+CameraState());
+switch ( activeView.iViewUid.iUid )
+{
+// if we are in the photo/video capture view and the
+// second camera is enabled then switch to the main camera
+// so long as video/photo capture is not in progress
+case ECamViewIdStillPreCapture:
+case ECamViewIdVideoPreCapture:
+{
+if ( iInfo.iActiveCamera == ECamActiveCameraSecondary &&
+iInfo.iOperation != ECamCapturing &&
+iInfo.iOperation != ECamPaused &&
+iInfo.iOperation != ECamPausing &&
+iInfo.iOperation != ECamResuming &&
+iInfo.iOperation != ECamCompleting &&
+(CameraState() == ECamCameraPreparedImage ||
+CameraState() == ECamCameraPreparedVideo
+||
+CameraState() == ECamCameraReserved ||
+CameraState() == ECamCameraPowerOn
+) &&
+!VideoRecordPending() )
+{
+PRINT( _L("Camera precapture 2nd camera - switching now") );
+SetCameraSwitchRequired( ESwitchSecondaryToPrimary );
+if ( !appUi->AppInBackground( ETrue ) )
+{
+appUi->HandleCommandL( ECamCmdSwitchCamera );
+}
+}
+else
+{
+PRINT( _L("Camera capturing, paused etc. in precapview") );
+if ( ECamViewIdVideoPreCapture == activeView.iViewUid.iUid &&
+( ECamCapturing == iInfo.iOperation ||
+ECamPaused == iInfo.iOperation ) )
+{
+StopVideoRecording(); // stop recording and save the video
+}
+if ( ECamActiveCameraSecondary == iInfo.iActiveCamera )
+{
+PRINT( _L("Camera HandleSlideOpenedL, switchCamera") );
+SetCameraSwitchRequired( ESwitchSecondaryToPrimary );
+if ( !appUi->AppInBackground( ETrue ) )
+{
+appUi->HandleCommandL( ECamCmdSwitchCamera );
+}
+}
+}
+}
+break;
+case ECamViewIdStillPostCapture:
+case ECamViewIdVideoPostCapture:
+{
+if ( ECamActiveCameraSecondary == iInfo.iActiveCamera )
+{
+SetCameraSwitchRequired( ESwitchSecondaryToPrimary );
+if ( !appUi->AppInBackground( ETrue ) )
+{
+appUi->HandleCommandL( ECamCmdSwitchCamera );
+}
+}
+}
+break;
+default:
+break;
+}
+}
+}
+else if ( viewErr == KErrNotFound &&
+iInfo.iActiveCamera == ECamActiveCameraSecondary )
+{
+// If no view is found it means that camera is in background.
+// We don't want to do camera switch in embdedded/embedding mode
+// post-capture when in background
+if ( ( !appUi->IsEmbedded() &&
+!appUi->Embedding() ) ||
+appUi->CurrentViewState() != ECamViewStatePostCapture )
+{
+PRINT( _L("Camera HandleSlideOpenedL => view not found, 2nd active") );
+iCameraSwitchRequired = ESwitchToUnknown;
+}
+}
+else
+{
+}
+NotifyControllerObservers( ECamEventSliderOpen );
+PRINT( _L("Camera <= CamAppController::HandleSlideOpenedL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::VideoViewFinderResourceId()
+// Resource Id for video viewfinder layout
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::VideoViewFinderResourceId( TCamVideoResolution aResolution )
+{
+PRINT( _L( "Camera => CCamAppController::VideoViewFinderResourceIdL"))
+TInt vidVFRes;
+TCamOrientation orient = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() )->CamOrientation();
+if( orient == ECamOrientationCamcorder || orient == ECamOrientationCamcorderLeft )
+{
+vidVFRes = CamUtility::MapVideoQualityToViewFinderRes( aResolution );
+}
+else
+{
+TInt resId;
+TInt err = CamUtility::GetPsiInt( ECamPsiVideoVFResSecondaryCamera, resId );
+if( err )
+{
+vidVFRes = ROID( R_CAM_VIEWFINDER_RECT_CIF_ID );
+}
+else
+{
+vidVFRes = ROID( resId );
+}
+}
+PRINT1( _L( "Camera => CCamAppController::VideoViewFinderResourceId res id "), vidVFRes )
+return vidVFRes;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandleObservedEvent()
+// Receives event codes from observables
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandleObservedEvent( TCamObserverEvent aEvent )
+{
+switch( aEvent )
+{
+case ECamObserverEventCaptureProcessComplete:
+{
+NotifyControllerObservers( ECamEventExitRequested, KErrNone );
+}
+break;
+default:
+break;
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsProfileSilent
+// Return whether current profile is silent or not, uses warning
+// tones setting to determine whether silent or not
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsProfileSilent()
+{
+TRAPD( ignore, iSilentProfile = IsProfileSilentL() );
+if ( ignore )
+{
+}
+return iSilentProfile;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsProfileSilentL
+// Return whether current profile is silent or not, uses warning
+// tones setting to determine whether silent or not
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsProfileSilentL()
+{
+// get current keypad volume as indication of whether
+// or not we have a silent profile
+CRepository* cr = CRepository::NewLC( KCRUidProfileEngine );
+TInt value;
+User::LeaveIfError( cr->Get( KProEngActiveWarningTones, value ) );
+CleanupStack::PopAndDestroy( cr );
+return ( value == 0 );
+}
+// ---------------------------------------------------------------------------
+// ResetInactivityTimer <<static>>
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::ResetInactivityTimer( TAny* /*aPtr*/ )
+{
+	PRINT( _L("Camera =><= CCamAppController::ResetInactivityTimer") );
+User::ResetInactivityTime();
+	return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ToneShouldBeSilent
+// Returns ETrue if the supplied toneId should be silent if the profile is
+// set to silent. Does *not* take into account network variant forcing
+// sounds on.
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::ToneShouldBeSilent( TCamSoundId aSoundId )
+{
+if ( aSoundId == CaptureToneId() ||
+aSoundId == ECamVideoStartSoundId ||
+aSoundId == ECamVideoStopSoundId ||
+aSoundId == ECamVideoPauseSoundId ||
+aSoundId == ECamVideoResumeSoundId ||
+aSoundId == ECamAutoFocusComplete ||
+aSoundId == ECamSelfTimerSoundId )
+{
+return ETrue;
+}
+else
+{
+return EFalse;
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::HandleCaptureCompletion
+// Inform any observers that are waiting for a capture completion event
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::HandleCaptureCompletion()
+{
+PRINT( _L( "Camera => CCamAppController::HandleCaptureCompletion()" ) )
+SetOperation( ECamNoOperation );
+// Re-enable screensaver
+EnableScreenSaver( ETrue );
+// If mmc dismount notification came while saving, allow the dismount now
+if( iDismountPending )
+{
+iDismountPending = EFalse;
+iDriveChangeNotifier->SendAllowDismount();
+}
+// If any observers are waiting for a capture completion event
+if ( iCaptureCompletionObserverHandler )
+{
+iCaptureCompletionObserverHandler->BroadcastEvent( ECamObserverEventCaptureProcessComplete );
+delete iCaptureCompletionObserverHandler;
+iCaptureCompletionObserverHandler = NULL;
+}
+// If the camera orientation changed during capture and not in burst mode,
+// set the new orientation
+if ( iConfigManager && iConfigManager->IsOrientationSensorSupported()
+&& iOrientationChangeOccured
+&& iInfo.iImageMode != ECamImageCaptureBurst )
+{
+iOrientationChangeOccured = EFalse;
+TRAP_IGNORE( SetImageOrientationL() );
+}
+if ( iPendingRelease )
+{
+PRINT( _L( "Camera <> CCamAppController::HandleCaptureCompletion(), DATAMAKE2" ) )
+ReleaseCamera();
+}
+PRINT( _L( "Camera <= CCamAppController::HandleCaptureCompletion()" ) )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CheckAfModeForScene
+// Checks the current scene/based on scene to see if AF mode needs setting
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CheckAfModeForScene( TBool aForceAFReset )
+{
+PRINT(_L("Camera => CCamAppController::CheckAfModeForScene"));
+if ( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestSetAfRange ) );
+}
+PRINT(_L("Camera <= CCamAppController::CheckAfModeForScene"));
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::TryAutoFocus
+// Start an AF operation, if needed
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::TryAutoFocus()
+{
+PRINT( _L("Camera => CCamAppController::TryAutoFocus()") );
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_TRYAUTOFOCUS, "e_CAM_APP_AF_LOCK 1" );  //CCORAPP_AF_LOCK_START
+if ( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+if( ECamActiveCameraPrimary != iInfo.iActiveCamera ||
+ECamControllerImage != iInfo.iMode )
+{
+PRINT( _L("Returning EFalse - Not using primary camera in still mode") );
+// Not using primary camera in still mode
+return EFalse; // Not focusing
+}
+PRINT( _L("Calling IssueDirectRequestL( ECamRequestStartAutofocus )") );
+return TryAFRequest( ECamRequestStartAutofocus );
+}
+else
+{
+return ETrue;
+}
+}
+// ---------------------------------------------------------
+// CCamAppController::CurrentSceneHasForcedFocus
+// Returns whether the current scene has focus forced to
+// a particular value ( eg Macro/Landscape modes may have
+// focus fixed to Macro/Infinite )
+// ---------------------------------------------------------
+//
+TBool CCamAppController::CurrentSceneHasForcedFocus() const
+{
+if ( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+// Work out what the current scene is (or if current scene is user
+// scene, what it's based on).
+TInt currentScene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );
+if ( currentScene  == ECamSceneUser )
+{
+currentScene = IntegerSettingValue( ECamSettingItemUserSceneBasedOnScene );
+}
+TBool isFaceTrackingOn = (iConfigManager &&
+iConfigManager->IsFaceTrackingSupported() &&
+(iSettingsModel->IntegerSettingValue(
+ECamSettingItemFaceTracking ) == ECamSettOn ) );
+// Check if the current (or based on) scene is one that should *not* have
+// a reticule.
+if ( ( currentScene == ECamSceneScenery
+|| currentScene == ECamSceneNightScenery
+|| currentScene == ECamSceneSports )
+&& !isFaceTrackingOn )
+{
+return ETrue;
+}
+else
+{
+return EFalse;
+}
+}
+else
+{
+return ETrue;
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CaptureToneDelayTimeout
+// Timeout from capture tone delay timer
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::CaptureToneDelayTimeout( TAny* aPtr )
+{
+PRINT( _L("Camera => CCamAppController::CaptureToneDelayTimeoutL") )
+static_cast<CCamAppController*>( aPtr )->PlayDelayedCaptureTone();
+return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PlayDelayedCaptureTone
+// Play capture tone
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::PlayDelayedCaptureTone()
+{
+PlaySound( CaptureToneId(), EFalse );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::InitAutoFocusL
+// Initalises the AutoFocus interface, if needed
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::InitAutoFocusL()
+{
+PRINT( _L("Camera => CCamAppController::InitAutoFocusL") )
+PRINT(_L("Camera !! DISABLED"));
+PRINT( _L("Camera <= CCamAppController::InitAutoFocusL") )
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CopySnapshotIfNeededL
+// Helper function for McaeoSnapImageReady that makes a copy of the snapshot
+// if needed to fake a viewfinder or for image rotation.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::CopySnapshotIfNeeded( const CFbsBitmap& aSnapshot, TInt aError )
+{
+if ( ECamImageCaptureTimeLapse == iInfo.iImageMode
+|| ECamControllerVideo == iInfo.iMode
+|| ( iConfigManager && iConfigManager->IsOrientationSensorSupported() &&
+iSettingsModel->IntegerSettingValue( ECamSettingItemImageRotation ) == ECamSettOn )
+)
+{
+StopIdleTimer();
+delete iSnapShotCopy;
+iSnapShotCopy = NULL;
+TRAP_IGNORE ( ( iSnapShotCopy = new(ELeave) CFbsBitmap() ) );
+if ( iSnapShotCopy )
+{
+TInt dupeError = iSnapShotCopy->Duplicate( aSnapshot.Handle() );
+if ( dupeError )
+{
+iSnapShotCopy->Reset();
+delete iSnapShotCopy;
+iSnapShotCopy = NULL;
+}
+else if ( iConfigManager && !iConfigManager->IsOrientationSensorSupported() )
+{
+if( ECamImageCaptureTimeLapse == iInfo.iImageMode )
+{
+// simulate the receipt of a viewfinder frame using the snapshot image
+// McaeoViewFinderFrameReady( *iSnapShotCopy, aError );
+HandleViewfinderFrame( aError, iSnapShotCopy );
+}
+}
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::EnableScreenSaver
+// Turns the screen saver on or off for timelapse capture
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::EnableScreenSaver( TBool aEnable )
+{
+if ( !aEnable )
+{
+// Stop the screensaver from appearing
+RProperty::Set( KPSUidScreenSaver, KScreenSaverAllowScreenSaver, 1 );
+}
+else
+{
+// Allow the screensaver to appear
+RProperty::Set( KPSUidScreenSaver, KScreenSaverAllowScreenSaver, 0 );
+User::ResetInactivityTime();
+}
+}
+#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT
+// ---------------------------------------------------------------------------
+// CCamAppController::SetPerformanceState
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetPerformanceState( TCamPerformanceState aState )
+{
+iPerformanceState = aState;
+}
+#endif
+// ---------------------------------------------------------------------------
+// CCamAppController::StartLocationTrailL()
+// Connects and starts the locationtrail
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StartLocationTrailL()
+{
+PRINT( _L("Camera => CCamAppController::StartLocationTrailL") );
+CCamAppUi* appUI = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// If a stop request is pending but the trail is being restarted, stop
+// and delete the timer
+if( iLocationTrailTimer )
+	{
+	iLocationTrailTimer->Cancel();
+	delete iLocationTrailTimer;
+	iLocationTrailTimer = NULL;
+	}
+TInt err = KErrNone;
+#if defined(RD_MDS_2_5) && !defined(__WINSCW__)
+if ( !iLocationTrailStarted )
+	  {
+	  if ( !iLocationUtilityConnected )
+	    {
+	    PRINT( _L("Camera => CCamAppController::StartLocationTrailL - iLocationUtility.Connect()") );
+	    TVwsViewId activeView;
+	    if ( appUI->GetActiveViewId( activeView ) == KErrNone )
+	      {
+	      if( ECamViewIdStillPreCapture == activeView.iViewUid.iUid  )
+	          {
+	          CCamPreCaptureViewBase* view = static_cast<CCamPreCaptureViewBase*>( appUI->View( activeView.iViewUid ) );
+	          view->SetLocationTrailConnecting();
+	          }
+	      }
+	    User::LeaveIfError( iLocationUtility.Connect() );
+	    iLocationUtilityConnected = ETrue;
+	    }
+	  err = iLocationUtility.StartLocationTrail( RLocationTrail::ECaptureAll );
+	  }
+#endif
+// If start fails, change the setting to off
+if( KErrNone != err )
+{
+PRINT1( _L("Camera :: CCamAppController::StartLocationTrailL error:%d encountered while starting location trail"), err )
+#if defined(RD_MDS_2_5) && !defined(__WINSCW__)
+// Disconnect from the location utility
+PRINT( _L("Camera => CCamAppController::StartLocationTrailL - Starting of LocationTrail failed -> iLocationUtility.Close()") );
+iLocationUtility.Close();
+iLocationUtilityConnected = EFalse;
+SetIntegerSettingValueL( ECamSettingItemRecLocation, ECamLocationOff );
+#endif
+// Going to standby mode, location trail disabled
+	  /*
+TVwsViewId activeView;
+if ( appUI->GetActiveViewId( activeView ) == KErrNone )
+{
+CCamViewBase* view = static_cast<CCamViewBase*>( appUI->View( activeView.iViewUid ) );
+view->SwitchToStandbyModeL( TCamAppViewIds(activeView.iViewUid.iUid), err );
+}
+*/
+appUI->SetStandbyStatus( err );
+appUI->HandleCommandL( ECamCmdGoToStandby );
+}
+else
+	{
+	iLocationTrailStarted = ETrue;
+	}
+PRINT( _L("Camera <= CCamAppController::StartLocationTrailL") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StopLocationTrail( TBool aCloseSession )
+// Stops the locationtrail
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StopLocationTrail( TBool aCloseSession )
+	  {
+	  PRINT1( _L("Camera => CCamAppController::StopLocationTrail operation mode:%d"), iInfo.iOperation );
+#if defined(RD_MDS_2_5) && !defined(__WINSCW__)
+	  if( iLocationTrailStarted )
+		{
+		// if not ECamCapturing, ECamPausing, ECamPaused, ECamResuming or ECamCompleting
+		if( (iInfo.iOperation < ECamCapturing || iInfo.iOperation > ECamCompleting ) &&
+		    ( CurrentFullFileName() == KNullDesC || SavedCurrentImage() )
+		  )
+			{
+			PRINT( _L("Camera :: CCamAppController::StopLocationTrail - stopping location trail") )
+			iLocationUtility.StopLocationTrail();
+			if ( aCloseSession )
+			    {
+			    PRINT( _L("Camera => CCamAppController::StartLocationTrailL - iLocationUtility.Close()") );
+			    iLocationUtility.Close();
+			    iLocationUtilityConnected = EFalse;
+			    }
+			iLocationTrailStarted = EFalse;
+			// If a timer was used to stop the location trail, then cancel and delete the timer
+	        if( iLocationTrailTimer )
+	        	{
+	        	iLocationTrailTimer->Cancel();
+	        	delete iLocationTrailTimer;
+	        	iLocationTrailTimer = NULL;
+	        	}
+			}
+		else
+			{
+			// Use a timer to close the trail in a few seconds
+	    	PRINT( _L("Camera :: CCamAppController::StopLocationTrail - location trail in use") )
+	    	if( !iLocationTrailTimer )
+	    		{
+	    		TRAP_IGNORE( iLocationTrailTimer = CCamTimer::NewL( KLocTrailCloseRetryTime,
+	    		  TCallBack( CCamAppController::RetryStopLocationTrail, this ) ) );
+	    		}
+	    	else // restart the timer
+	    		{
+				iLocationTrailTimer->Cancel();
+				iLocationTrailTimer->SetTimeout( KLocTrailCloseRetryTime );
+	    		}
+	    	iLocationTrailTimer->StartTimer();
+			}
+		}
+	#endif
+	  PRINT( _L("Camera <= CCamAppController::StopLocationTrail") );
+	  }
+// ---------------------------------------------------------------------------
+// CCamAppController::RetryStopLocationTrail()
+// Timer callback function to attempt to remove the location trail periodically
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::RetryStopLocationTrail( TAny* aPtr )
+	{
+	PRINT( _L("Camera => CCamAppController::RetryStopLocationTrail") )
+	static_cast<CCamAppController*>( aPtr )->StopLocationTrail();
+	PRINT( _L("Camera <= CCamAppController::RetryStopLocationTrail") )
+	return KErrNone;
+	}
+// -----------------------------------------------------------------------------
+// CCamAppController::CaptureKeyPressedWhileImageSaving
+// Whether or not a capture key pressed during image saving
+// -----------------------------------------------------------------------------
+//
+TBool CCamAppController::CaptureKeyPressedWhileImageSaving() const
+	{
+	return iCaptureKeyPressedWhileImageSaving;
+	}
+// -----------------------------------------------------------------------------
+// CCamAppController::SetCaptureKeyPressedWhileImageSaving
+// -----------------------------------------------------------------------------
+//
+void CCamAppController::SetCaptureKeyPressedWhileImageSaving(TBool aCaptureKeyPressed)
+	{
+	iCaptureKeyPressedWhileImageSaving = aCaptureKeyPressed;
+	}
+// ---------------------------------------------------------------------------
+// CamerasAvailable <<static>>
+//
+// Commonly needed in UI classes, so added also support to get this info
+// through this class. This way we avoid unnecessary binding of
+// CCameraController and UI classes.
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamAppController::CamerasAvailable()
+{
+return CCamCameraController::CamerasAvailable();
+}
+TBool
+CCamAppController::TimeLapseSupported()
+{
+return (ECamSupportOn == iSettingsModel->VariantInfo().iTimeLapseSupport);
+}
+TBool
+CCamAppController::AlwaysOnSupported()
+{
+return (ECamSupportOn == iSettingsModel->VariantInfo().iAlwaysOnSupport);
+}
+const TVersion&
+CCamAppController::Version()
+{
+return iSettingsModel->VariantInfo().iVersion;
+}
+// <<public>>
+TBool
+CCamAppController::Busy() const
+{
+return (EBusyNone != iBusyFlags || CameraControllerBusy() );
+}
+TBool
+CCamAppController::CameraControllerBusy() const
+{
+return (iCameraController && ECamBusyOff != iCameraController->ControllerInfo().iBusy );
+}
+// ===========================================================================
+// From MCamCameraObserver
+// ---------------------------------------------------------------------------
+// HandleCameraEventL <<virtual>>
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::HandleCameraEventL( TInt              aStatus,
+TCamCameraEventId aEventId,
+TAny*             aEventData /*= NULL*/ )
+{
+#ifdef _DEBUG
+// Log viewfinder events with PRINT_FRQ
+// #ifdef _DEBUG is used to avoid extra if in release builds
+// where logging is not used anyway.
+if( ECamCameraEventVfFrameReady == aEventId )
+{
+PRINT_FRQ1( _L( "Camera => CCamAppController::HandleCameraEventL, event[%s]" ),
+KCamCameraEventNames[aEventId] );
+}
+else
+#endif // _DEBUG
+{
+PRINT1( _L( "Camera => CCamAppController::HandleCameraEventL, event[%s]" ),
+KCamCameraEventNames[aEventId] );
+}
+// in case we get poweron event before appui is completely constructed
+// finish it here
+if ( aEventId == ECamCameraEventPowerOn )
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( iConfigManager &&
+iConfigManager->IsUIOrientationOverrideSupported() &&
+!appUi->IsUiConstructionComplete() )
+{
+appUi->AppUIConstructCallbackL( appUi );
+}
+}
+TInt handleError( KErrNone );
+if( ECamCameraEventVfFrameReady != aEventId &&
+KErrNone == aStatus || KErrDiskFull == aStatus || KErrCompletion == aStatus )
+{
+// Called for all events, except viewfinder frame ready event.
+SetStateFromEvent( aEventId );
+}
+if( ECamCameraEventImageInit == aEventId ||
+ECamCameraEventVideoInit == aEventId )
+{
+iSettingsRestoreNeeded = ETrue;
+}
+// NOTE: Consider that the ones needing these events
+//       receive them directly from Camera Controller?
+switch( aEventId )
+{
+case ECamCameraEventVfStart:
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+// For forced focus scenes, do one autofocus request once vf starts if needed
+if( UiConfigManagerPtr()->IsAutoFocusSupported() )
+{
+if( CurrentSceneHasForcedFocus() || UiConfigManagerPtr()->IsAutofocusSetInHyperfocalAtStartup() )
+{
+PRINT( _L( "Camera => CCamAppController::HandleCameraEventL, TryAFRequest( ECamRequestCancelAutofocus )") );
+TryAFRequest( ECamRequestCancelAutofocus );
+}
+}
+if( iSettingsRestoreNeeded )
+{
+iSettingsRestoreNeeded = EFalse;
+TRAP( aStatus, RestoreSettingsToCameraL() );
+}
+// fixed toolbar is used only with touch devices
+if ( IsTouchScreenSupported() )
+{
+appUi->SetToolbarVisibility();// avoid flickering in settings view
+PRINT( _L( "Camera <> SetToolbarVisibility done ") );
+}
+// else use AP
+else
+{
+if( iConfigManager && iConfigManager->IsUIOrientationOverrideSupported() )
+{
+NotifyControllerObservers( ECamEventInitReady );
+}
+}
+if ( UiConfigManagerPtr()->IsLocationSupported() &&
+!appUi->IsEmbedded())
+{
+if( ECamLocationOn == IntegerSettingValue( ECamSettingItemRecLocation ) )
+{
+if( ECamActiveCameraPrimary == ActiveCamera() && ECamStandby != CurrentOperation() )
+{
+StartLocationTrailL();
+}
+else // Secondary camera
+{
+PRINT( _L("Camera: CCamAppController::HandleCameraEventL - secondary camera, stop location trail") )
+StopLocationTrail();
+}
+}
+}
+break;
+}
+case ECamCameraEventVfFrameReady:
+{
+HandleViewfinderFrame( aStatus, static_cast<CFbsBitmap*>( aEventData ) );
+if( KErrNone == aStatus && iSettingsRestoreNeeded )
+{
+iSettingsRestoreNeeded = EFalse;
+TRAP( aStatus, RestoreSettingsToCameraL() );
+}
+return;
+}
+case ECamCameraEventSsReady:
+{
+TRAP_IGNORE( HandleSnapshotEvent( aStatus, static_cast<CFbsBitmap*>( aEventData ) ) );
+if ( ECamImageCaptureBurst == iInfo.iImageMode &&
+CurrentCapturedCount() < CaptureLimit() )
+{
+// check memory level
+TInt memoryLeft = 0;
+HAL::Get( HALData::EMemoryRAMFree, memoryLeft );
+if ( memoryLeft < KCriticalMemoryLevel )
+{
+PRINT( _L("Camera <> RAM is below critical level #1") )
+// memory below critical level, need to stop capture
+SoftStopBurstL( ETrue );
+EventHandlingErrorRecovery( KErrNoMemory );
+}
+}
+break;
+}
+case ECamCameraEventImageData:
+{
+//      TRAP_IGNORE( HandleImageCaptureEventL( aStatus, static_cast<HBufC8*>( aEventData ) ) );
+TRAP_IGNORE( HandleImageCaptureEventL( aStatus, static_cast<CCamBufferShare*>( aEventData ) ) );
+if ( ECamImageCaptureBurst == iInfo.iImageMode &&
+CurrentCapturedCount() < CaptureLimit() )
+{
+// check memory level
+TInt memoryLeft = 0;
+HAL::Get( HALData::EMemoryRAMFree, memoryLeft );
+if ( memoryLeft < KCriticalMemoryLevel )
+{
+PRINT( _L("Camera <> RAM is below critical level #2") )
+// memory below critical level, need to stop capture
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestImageCancel ) );
+EventHandlingErrorRecovery( KErrNoMemory );
+}
+}
+break;
+}
+case ECamCameraEventImageStop:
+{
+TRAP( aStatus, HandleImageStopEventL( aStatus, aEventData ? *static_cast<TInt*>( aEventData ) : 0 ) );
+break;
+}
+case ECamCameraEventAutofocusSuccessful: // Flowthrough
+case ECamCameraEventAutofocusFailed:
+{
+// Autofocusing is done, do possible pending capture
+SetAfNeeded( EFalse );
+if( iCaptureRequested && !EngineProcessingCapture() )
+{
+iCaptureRequested = EFalse;
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_PRI_SHOT_TO_SAVE 1" );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_PRI_SHOT_TO_SHOT 1" );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_APP_SHOT_TO_STILL 1" );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_APP_CAPTURE_START 1" );
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_PRI_SERIAL_SHOOTING 1" );
+Capture();
+}
+break;
+}
+case ECamCameraEventSettingsSingle:
+{
+TRAP_IGNORE( HandleSettingEventL( aStatus, aEventId, aEventData ) );
+return;
+}
+case ECamCameraEventVideoAsyncStop:
+case ECamCameraEventVideoStop:
+{
+// we always want to handle these events. set the flag because
+// there is a possibility that some other event has come before
+// and caused the flag to be cleared
+SetFlags(iBusyFlags, EBusyRequest);
+if ( !IsMemoryAvailable( ECamMediaStorageCard, EFalse )
+	     && CurrentStorage() == ECamMediaStorageCard )
+	{
+aStatus = KErrNone;
+	}
+if( aStatus != KErrNone && aStatus != KErrDiskFull && aStatus != KErrCompletion
+&& !( aStatus == KErrPathNotFound && IsCaptureStoppedForUsb() ) )
+{
+iSaving = EFalse;
+SetOperation( ECamStandby, KErrGeneral );
+}
+else
+{
+// In case of no error, we are already in appropriate state
+}
+	  break;
+}
+case ECamCameraEventIveRecover:
+{
+if( !Busy() )
+{
+PRINT( _L( "Camera => CCamAppController::HandleCameraEventL - Issue new recovery sequence" ) );
+SetStateFromEvent( ECamCameraEventReserveLose );
+SetTargetMode( ECamControllerImage );
+SetTargetImageMode( CurrentImageModeSetup() );
+IssueModeChangeSequenceL();
+}
+else
+{
+PRINT( _L( "Camera => CCamAppController::HandleCameraEventL - Recovery sequence is active" ) );
+}
+break;
+}
+case ECamCameraEventSequenceEnd:
+{
+// only for image mode
+if( iConfigManager && iConfigManager->IsOrientationSensorSupported()
+&& ECamControllerImage == CurrentMode() )
+{
+// If the camera orientation changed during initialization sequence and not in burst mode,
+// set the new orientation
+if ( iOrientationChangeOccured &&
+iInfo.iImageMode != ECamImageCaptureBurst )
+{
+iOrientationChangeOccured = EFalse;
+TRAP_IGNORE( SetImageOrientationL() );
+}
+if( !iAccSensorListening )
+{
+TRAP_IGNORE( UpdateSensorApiL( ETrue ) );
+}
+}
+if ( aStatus == KErrCancel )
+{
+// sequence canceled, no need to event further
+return;
+}
+break;
+}
+default:
+break;
+}
+// -------------------------------------------------------
+// We have requested a series of operations.
+// The sequences have ids, which we use to determine
+// the right procedure. React when sequence ends.
+if( IsFlagOn( iBusyFlags, EBusySequence ) )
+{
+PRINT( _L( "Camera <> Sequence of requests pending" ) );
+TRAP( handleError, HandleSequenceEventL( aStatus, aEventId, aEventData ) );
+}
+// -------------------------------------------------------
+// We have single request pending.
+else if( IsFlagOn( iBusyFlags, EBusyRequest ) )
+{
+PRINT( _L( "Camera <> Single request pending" ) );
+TRAP( handleError, HandleRequestEventL( aStatus, aEventId, aEventData ) );
+}
+else if( IsFlagOn( iBusyFlags, EBusySetting ) )
+{
+PRINT( _L( "Camera <> Settings finished" ) );
+TRAP( handleError, HandleSettingEventL( aStatus, aEventId, aEventData ) );
+}
+// -------------------------------------------------------
+// No request pending for us.
+// Direct request issued to Camera controller.
+else
+{
+PRINT( _L( "Camera <> No requests pending!!" ) );
+// handle these ..
+}
+// -------------------------------------------------------
+if( KErrNone != handleError )
+{
+EventHandlingErrorRecovery( handleError );
+}
+// Reserve lost event is always handled.
+if( ECamCameraEventReserveLose == aEventId && KErrNone != aStatus )
+{
+SetOperation( ECamStandby, aStatus );
+}
+if( iPendingRelease && !Busy() &&
+!IsSavingInProgress() && iInfo.iOperation != ECamCapturing )
+{
+// Finally, if camera release is pending, and we are no longer busy,
+// call ReleaseCamera to get it done.
+// ReleaseCamera is used instead of simply setting iInfo.iTargetMode,
+// because it also handles stopping ongoing burst captures.
+PRINT( _L( "Camera <> CCamAppController::HandleCameraEventL, release pending, calling ReleaseCamera..") );
+ReleaseCamera();
+}
+#ifdef _DEBUG
+// Log viewfinder events with PRINT_FRQ
+if( ECamCameraEventVfFrameReady == aEventId )
+{
+PRINT_FRQ( _L( "Camera <= CCamAppController::HandleCameraEventL" ) );
+}
+else
+#endif // _DEBUG
+{
+PRINT( _L( "Camera <= CCamAppController::HandleCameraEventL" ) );
+}
+}
+// ===========================================================================
+// ---------------------------------------------------------------------------
+// EventHandlingErrorRecovery
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::EventHandlingErrorRecovery( TInt aError )
+{
+PRINT1( _L( "Camera => CCamAppController::EventHandlingErrorRecovery, error:%d" ), aError );
+__ASSERT_ALWAYS( aError != KErrNone, CamPanic( ECamPanicInvalidState ) );
+iCaptureModeTransitionInProgress = EFalse;
+// Reset the saving flag to ensure that camera does not get stuck
+iSaving = EFalse;
+iMuteNotifications = ETrue;
+// Cancel ongoing sequence if any
+iCameraController->CancelSequence();
+// Clear busy flags
+iBusyFlags           = EBusyNone;
+iInfo.iBusyRequestId = ECamRequestNone;
+iMuteNotifications = EFalse;
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+//Don't change to Stand by mode if -4 error gotten during burst (somehow expected)
+if(SequenceCaptureInProgress() && appUi->CurrentBurstMode() == ECamImageCaptureBurst && KErrNoMemory == aError )
+{
+TRAP_IGNORE( appUi->HandleCameraErrorL(aError) );
+}
+else
+{
+SetOperation( ECamStandby, aError );
+}
+NotifyControllerObservers( ECamEventControllerReady, aError );
+PRINT( _L( "Camera <= CCamAppController::EventHandlingErrorRecovery" ) );
+}
+// ---------------------------------------------------------------------------
+// HandleSettingEventL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleSettingEventL( TInt              aStatus,
+TCamCameraEventId aEventId,
+TAny*             aEventData )
+{
+PRINT( _L( "Camera => CCamAppController::HandleSettingEventL" ) );
+// -------------------------------------------------------
+if( ECamCameraEventSettingsDone == aEventId )
+{
+ClearFlags( iBusyFlags, EBusySetting );
+// Need to clear any pending settings.
+iSettingProvider->Reset();
+if( IsInShutdownMode() && iInfo.iMode != ECamControllerIdle && iInfo.iMode != ECamControllerShutdown )
+{
+PRINT( _L( "Camera <> CCamAppController: Releasing camera.." ) );
+IssueRequestL( ECamRequestRelease );
+}
+else
+{
+PRINT( _L( "Camera <> CCamAppController: Got setting end event.." ) );
+if( KErrNone != aStatus )
+{
+TCamCameraSettingId* cameraSetting =
+static_cast<TCamCameraSettingId*>( aEventData );
+// Leave with the incoming error, if setting id not provided.
+CheckNonNullL( cameraSetting, aStatus );
+if( ECameraSettingFileName == *cameraSetting )
+{
+DoVideoNameRetryL( aStatus );
+}
+else
+{
+User::Leave( aStatus );
+}
+}
+else
+{
+ProceedPendingOrNotifyReadyL();
+}
+}
+}
+// -------------------------------------------------------
+else if( ECamCameraEventSettingsSingle == aEventId )
+{
+TCamCameraSettingId* cameraSetting =
+static_cast<TCamCameraSettingId*>( aEventData );
+CheckNonNullL( cameraSetting, KErrNotFound );
+switch( *cameraSetting )
+{
+case ECameraSettingDigitalZoom:
+case ECameraSettingOpticalZoom:
+{
+PRINT( _L( "Camera <> CCamAppController: zoom event" ) );
+NotifyControllerObservers( ECamEventZoomStateChanged, aStatus );
+// Pending zooming done in HandleViewfinderFrame
+break;
+}
+default:
+PRINT( _L( "Camera <> CCamAppController: unhandled setting event" ) );
+break;
+}
+}
+// -------------------------------------------------------
+else
+{
+// Ignored
+}
+// -------------------------------------------------------
+PRINT( _L( "Camera <= CCamAppController::HandleSettingEventL" ) );
+}
+// ---------------------------------------------------------------------------
+// DoVideoNameRetryL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::DoVideoNameRetryL( TInt aStatus )
+{
+PRINT( _L( "Camera => CCamAppController::DoVideoNameRetryL" ) );
+if ( IsFlagOn( iCameraController->State(), ECamVideoOn )
+&& iVideoNameRetries > 0 )
+{
+PRINT1( _L( "Camera <> video rename failed retries = %d retrying rename" ), iVideoNameRetries );
+// Try again
+--iVideoNameRetries;
+TRAP_IGNORE( GenerateNextValidVideoPathL() );
+if ( ECamCapturing != iInfo.iOperation && ECamPaused != iInfo.iOperation )
+{
+iSettingProvider->AddPendingSettingChangeL( ECamSettingItemVideoNameBase );
+}
+IssueSettingsChangeRequestL();
+}
+else if ( KErrDiskFull         == aStatus
+&& ECamMediaStorageCard == IntegerSettingValue( ECamSettingItemVideoMediaStorage ) )
+{
+PRINT( _L( "Camera McaeoVideoPrepareComplete disk full and set to memory card " ) );
+NotifyControllerObservers( ECamEventInvalidMemoryCard );
+// ForceUsePhoneMemory
+if( ExistMassStorage() )
+{
+TRAP_IGNORE(
+{
+iSettingsModel->SetIntegerSettingValueL( ECamSettingItemVideoMediaStorage,
+									     ECamMediaStorageMassStorage );
+GenerateNextValidVideoPathL();
+});
+}
+else
+{
+TRAP_IGNORE(
+{
+iSettingsModel->SetIntegerSettingValueL( ECamSettingItemVideoMediaStorage,
+ECamMediaStoragePhone );
+GenerateNextValidVideoPathL();
+});
+}
+iSettingProvider->AddPendingSettingChangeL( ECamSettingItemVideoMediaStorage );
+IssueSettingsChangeRequestL();
+}
+// No retries left
+else
+{
+PRINT1( _L( "Camera <> video prep failed retries = %d removing iVideoRequested" ), iVideoNameRetries );
+// remove pending request, so that new attempts to record are not blocked
+if ( iVideoRequested )
+iVideoRequested = EFalse;
+User::LeaveIfError( aStatus );
+}
+PRINT( _L( "Camera <= CCamAppController::DoVideoNameRetryL" ) );
+}
+// ---------------------------------------------------------------------------
+// HandleCameraSequenceComplete
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleSequenceEventL( TInt              aStatus,
+TCamCameraEventId aEventId,
+TAny*             /*aEventData*/ )
+{
+PRINT( _L( "Camera => CCamAppController::HandleSequenceEventL" ) );
+if( iDismountPending &&
+( ECamCameraEventImageInit == aEventId ||
+ECamCameraEventVideoInit == aEventId ||
+ECamCameraEventSequenceEnd == aEventId ) )
+{
+iDismountPending = EFalse;
+iDriveChangeNotifier->SendAllowDismount();
+}
+if( ECamCameraEventSequenceEnd == aEventId )
+{
+ClearFlags( iBusyFlags, EBusySequence );
+if( IsInShutdownMode() && iInfo.iMode != ECamControllerIdle && iInfo.iMode != ECamControllerShutdown )
+{
+PRINT( _L( "Camera <> In shutdown mode!!" ) );
+IssueRequestL( ECamRequestRelease );
+}
+else
+{
+User::LeaveIfError( aStatus );
+if( iCameraController && !iCameraController->IsWaitingIveResources() )
+{
+PRINT( _L( "Camera <> sequence end, proceed with pending.." ) );
+ProceedPendingOrNotifyReadyL();
+}
+}
+}
+PRINT( _L( "Camera <= CCamAppController::HandleSequenceEventL" ) );
+}
+// ---------------------------------------------------------------------------
+// HandleRequestEventL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::HandleRequestEventL( TInt              aStatus,
+TCamCameraEventId aEventId,
+TAny*             /*aEventData*/ )
+{
+PRINT( _L( "Camera => CCamAppController::HandleRequestEventL" ) );
+// Check if pending operations that need immediate attention.
+if( IsInShutdownMode() && iInfo.iMode != ECamControllerIdle &&
+iInfo.iMode != ECamControllerShutdown &&
+!iSaving && iInfo.iOperation != ECamCapturing &&
+iInfo.iOperation != ECamCompleting )
+{
+PRINT( _L( "Camera <> in shutdown mode, release camera.." ) );
+IssueDirectRequestL( ECamRequestRelease );
+}
+else
+{
+if( ECamCameraEventVideoStop == aEventId )
+{
+ClearFlags( iBusyFlags, EBusyRequest );
+HandleVideoStopEvent( aStatus );
+//If postcapture view is set to off notify controller ready event
+//for updating counter.
+if(IntegerSettingValue(ECamSettingItemVideoShowCapturedVideo)!=ECamSettOn )
+{
+NotifyControllerObservers( ECamEventControllerReady, KErrNone );
+}
+}
+else if( ECamCameraEventVideoAsyncStop == aEventId )
+{
+HandleVideoAsyncStopEvent( aStatus );
+}
+else
+{
+// Error handling in one place
+User::LeaveIfError( aStatus );
+// If our request is fully processed.
+if( !CameraControllerBusy() )
+{
+PRINT( _L( "Camera <> camera not busy, proceed or notify ready.." ) );
+ClearFlags( iBusyFlags, EBusyRequest );
+ProceedPendingOrNotifyReadyL();
+}
+}
+}
+PRINT( _L( "Camera <= CCamAppController::HandleRequestEventL" ) );
+}
+// ---------------------------------------------------------------------------
+// IssueRequestL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::IssueRequestL( const TCamCameraRequestId& aId )
+{
+PRINT1( _L("Camera => CCamAppController::IssueRequestL request[%s]"), KCamRequestNames[aId] );
+SetFlags( iBusyFlags, EBusyRequest );
+iInfo.iBusyRequestId = aId;
+TRAPD( error, iCameraController->RequestL( iInfo.iBusyRequestId ) );
+if( error != KErrNone )
+{
+ClearFlags( iBusyFlags, EBusyRequest );
+iInfo.iBusyRequestId = ECamRequestNone;
+User::Leave( error );
+}
+PRINT( _L("Camera <= CCamAppController::IssueRequestL") );
+}
+// ---------------------------------------------------------------------------
+// IssueDirectRequestL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController
+::IssueDirectRequestL( const TCamCameraRequestId& aId )
+{
+PRINT( _L("Camera => CCamAppController::IssueDirectRequestL") );
+iCameraController->DirectRequestL( aId );
+PRINT( _L("Camera <= CCamAppController::IssueDirectRequestL") );
+}
+// ---------------------------------------------------------------------------
+// IssueSettingsChangeRequestL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::IssueSettingsChangeRequestL()
+{
+PRINT( _L("Camera => CCamAppController::IssueSettingsChangeRequestL") );
+SetFlags( iBusyFlags, EBusySetting );
+TRAPD( error, iCameraController->RequestSettingsChangeL() );
+if( KErrNone != error )
+{
+ClearFlags( iBusyFlags, EBusySetting );
+User::Leave( error );
+}
+PRINT( _L("Camera <= CCamAppController::IssueSettingsChangeRequestL") );
+}
+// ---------------------------------------------------------------------------
+// ProceedPendingOrNotifyReadyL
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::ProceedPendingOrNotifyReadyL()
+{
+PRINT( _L("Camera => CCamAppController::ProceedPendingOrNotifyReadyL") );
+PRINT4( _L("Camera <> iMode[%s] iTargetMode[%s] iImageMode[%s] iTargetImageMode[%s]"),
+KCamModeNames[iInfo.iMode],
+KCamModeNames[iInfo.iTargetMode],
+KCamImageModeNames[iInfo.iImageMode],
+KCamImageModeNames[iInfo.iTargetImageMode] );
+__ASSERT_DEBUG( iCameraController, CamPanic( ECamPanicNullPointer ) );
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if( iInfo.iMode != iInfo.iTargetMode )
+{
+if ( !IsInShutdownMode() && !iSaving && iInfo.iOperation != ECamCapturing )
+{
+PRINT( _L("Camera <> CCamAppController: not in target mode, need to issue requests") );
+IssueModeChangeSequenceL();
+}
+}
+else if( iCameraController->ViewfinderState() != iInfo.iTargetVfState &&
+IsAppUiAvailable () &&
+!appUi->AppInBackground( ETrue ) &&
+!( iConfigManager && iConfigManager->IsUIOrientationOverrideSupported() &&
+iPendingRelease ) )
+{
+PRINT( _L("Camera <> CCamAppController: need to start/stop viewfinder..") );
+IssueModeChangeSequenceL();
+}
+else if( iSettingProvider
+&& iSettingProvider->PendingSettingChangeCount() > 0 )
+{
+PRINT( _L("Camera <> CCamAppController: settings pending, proceed now..") );
+IssueSettingsChangeRequestL();
+}
+else if( iVideoPrepareNeeded )
+{
+PRINT( _L("Camera <> CCamAppController: video prepare pending, proceed now..") );
+iVideoPrepareNeeded = EFalse;
+IssueRequestL( ECamRequestVideoInit );
+}
+else
+{
+PRINT( _L("Camera <> CCamAppController: Target mode achieved") );
+if( iCaptureModeTransitionInProgress )
+{
+PRINT( _L("Camera <> CCamAppController: capture mode transition complete") );
+iCaptureModeTransitionInProgress = EFalse;
+SetImageMode( iInfo.iTargetImageMode );
+}
+if ( iSetNewPathnamesPending > ECamMediaStorageNone )
+{
+TRAP_IGNORE( SetPathnamesToNewStorageL( iSetNewPathnamesPending ) );
+}
+if( iVideoRequested )
+{
+PRINT( _L("Camera <> starting recording..") );
+iVideoRequested = EFalse;
+IssueRequestL( ECamRequestVideoStart );
+PRINT( _L("Camera <> ..done") );
+}
+NotifyControllerObservers( ECamEventEngineStateChanged, KErrNone );
+NotifyControllerObservers( ECamEventControllerReady,    KErrNone );
+}
+PRINT( _L("Camera <= CCamAppController::ProceedPendingOrNotifyReadyL") );
+}
+// ---------------------------------------------------------------------------
+// SetStateFromEvent
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetStateFromEvent( TCamCameraEventId aEventId )
+{
+PRINT3( _L("Camera => CCamAppController::SetStateFromEvent mode[%s] operation[%s] event[%s]"),
+KCamModeNames[iInfo.iMode],
+KCamCaptureOperationNames[iInfo.iOperation],
+KCamCameraEventNames[aEventId]
+);
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+switch( aEventId )
+{
+// =================================
+case ECamCameraEventReserveLose:
+// SetMode( ECamControllerShutdown );
+SetMode( ECamControllerIdle );
+SetOperation( ECamNoOperation );
+break;
+// ---------------------------------
+case ECamCameraEventPowerOn:
+PRINT( _L("Camera <> Init key sound system..") );
+iSoundPlayer->InitKeySoundSystem();
+PRINT( _L("Camera <> ..Init key sound system done") );
+break;
+// ---------------------------------
+case ECamCameraEventPowerOff:
+// Reset the flash error status
+if( iFlashStatus ) iFlashStatus->SetFlashError( EFalse );
+SetMode( ECamControllerIdle );
+SetOperation( ECamNoOperation );
+break;
+// =================================
+// VF events
+case ECamCameraEventVfStart:
+if(  iBacklightTimer
+&& !iBacklightTimer->IsActive() )
+{
+//iBacklightTimer->Start( KBacklighTimerInterval,
+//                        KBacklighTimerInterval,
+//                        TCallBack( ResetInactivityTimer, this ) );
+iBacklightTimer->Start( 0,
+KBacklighTimerInterval,
+TCallBack( ResetInactivityTimer, this ) );
+}
+		iAFCancelInProgress = EFalse;
+break;
+// ---------------------------------
+case ECamCameraEventVfStop:
+if( iBacklightTimer )
+{
+iBacklightTimer->Cancel();
+}
+break;
+// =================================
+case ECamCameraEventImageInit:
+PRINT ( _L("Camera <> CCamAppController::SetStateFromEvent .. case ECamCameraEventImageInit") );
+SetMode( ECamControllerImage );
+// Set the capture count now, so we don't need to set it when starting capture.
+TRAP_IGNORE( InitCaptureLimitL() );
+SetOperation( ECamNoOperation );
+NotifyControllerObservers( ECamEventImageQualityChanged );
+break;
+// ---------------------------------
+case ECamCameraEventImageStart: // Capture started, not finished.
+PRINT ( _L("Camera <> CCamAppController::SetStateFromEvent .. case ECamCameraEventImageStart") );
+SetOperation( ECamCapturing );
+// Make sure our cached value for image filename number is up to date.
+iImageNumberCache = IntegerSettingValue( ECamSettingItemPhotoNumber );
+break;
+// ---------------------------------
+case ECamCameraEventImageStop: // Capture finished, unless in burst
+PRINT ( _L("Camera <> CCamAppController::SetStateFromEvent .. case ECamCameraEventImageStop") );
+// Store image counter now.
+TRAP_IGNORE( SetIntegerSettingValueL( ECamSettingItemPhotoNumber, iImageNumberCache ) );
+if ( ECamImageCaptureBurst != iInfo.iImageMode )
+{
+//If canceled autofocusing previously then have to set
+//autofocus range to get autofocusing work again.
+if(iAFCancelInProgress )
+{
+iAFCancelInProgress = EFalse;
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestSetAfRange ) );
+}
+// No operation change here.
+// Set to Completing in SS event, and ECamNoOperation when image saved.
+//        SetOperation( ECamNoOperation );
+}
+break;
+// ---------------------------------
+case ECamCameraEventImageRelease:
+SetMode( ECamControllerIdle );
+SetOperation( ECamNoOperation );
+break;
+// =================================
+case ECamCameraEventVideoInit:
+SetMode( ECamControllerVideo );
+SetOperation( ECamNoOperation );
+break;
+// ---------------------------------
+case ECamCameraEventVideoStart:
+iVideoRequested = EFalse;
+SetOperation( ECamCapturing );
+break;
+// ---------------------------------
+case ECamCameraEventVideoPause:
+PlaySound( ECamVideoPauseSoundId, EFalse );
+SetOperation( ECamPaused );
+break;
+// ---------------------------------
+case ECamCameraEventVideoStop:
+SetOperation( ECamCompleting );
+break;
+// ---------------------------------
+case ECamCameraEventVideoRelease:
+SetMode( ECamControllerIdle );
+SetOperation( ECamNoOperation );
+break;
+// =================================
+case ECamCameraEventStartAutofocus:
+if ( !CurrentSceneHasForcedFocus() &&
+!iAFCancelInProgress )
+{
+PRINT( _L("ECamCameraEventStartAutofocus -> Set operation state to ECamFocusing") );
+iCurrentAFRequest=ECamRequestStartAutofocus;
+SetOperation( ECamFocusing );
+// fixed toolbar is used only with touch devices
+if ( IsTouchScreenSupported() )
+{
+CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();
+if ( fixedToolbar )
+{
+fixedToolbar->SetToolbarVisibility( EFalse );
+}
+}
+}
+break;
+// ---------------------------------
+case ECamCameraEventAutofocusSuccessful:
+case ECamCameraEventAutofocusFailed:
+{
+OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPCONTROLLER_SETSTATEFROMEVENT, "e_CAM_APP_AF_LOCK 0" ); //CCORAPP_AF_LOCK_END
+OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPCONTROLLER_SETSTATEFROMEVENT, "e_CAM_APP_OVERLAY_UPD 1" );    //CCORAPP_OVERLAY_UPD_START
+PRINT2( _L("Camera <> CCamAppController::SetStateFromEvent - iPendingAFRequest[%s] iCurrentAFRequest[%s]"),
+KCamRequestNames[iPendingAFRequest],
+KCamRequestNames[iCurrentAFRequest] );
+	    if( iAFCancelInProgress && ECamRequestCancelAutofocus == iCurrentAFRequest &&
+	         ECamRequestCancelAutofocus == iPendingAFRequest )
+		    {
+// Cancelling done, camera lens is in hyperfocal position.
+// Return AF range back to normal, so that next autofocus request
+// will use the right range for this scene.
+iAFCancelInProgress = EFalse;
+TRAP_IGNORE( iCameraController->DirectRequestL( ECamRequestSetAfRange ) );
+		    iPendingAFRequest=0;
+		    iCurrentAFRequest=0;
+		    NotifyControllerObservers( ECamEventFocusCancelled );
+if ( !iCaptureRequested )
+{
+SetOperation( ECamNoOperation );
+}
+else
+{
+// do not notify observers if this happens after capture
+// has been requested as that would result in invalid ui state
+iInfo.iOperation = ECamNoOperation;
+if( IsAfNeeded() )
+{
+SetAfNeeded( EFalse );
+StartAutoFocus();
+}
+}
+		    }
+		 else if( iCurrentAFRequest==iPendingAFRequest &&
+		        iPendingAFRequest==ECamRequestStartAutofocus
+&& !CurrentSceneHasForcedFocus()
+)
+{
+	         if( aEventId==ECamCameraEventAutofocusSuccessful )
+	            {
+PRINT( _L("ECamCameraEventAutofocusSuccessful -> Set operation state to ECamFocused") );
+if( iConfigManager && iConfigManager->IsAutoFocusSupported() &&
+!iCaptureRequested && appUi &&	appUi->SelfTimer() &&
+!appUi->SelfTimer()->IsActive())
+{
+PlaySound( ECamAutoFocusComplete, EFalse );
+}
+SetOperation( ECamFocused );
+	            }
+	        else if(  aEventId==ECamCameraEventAutofocusFailed )
+	    	    {
+PRINT( _L("ECamCameraEventAutofocusFailed -> Set operation state to ECamFocusFailed") );
+if ( iConfigManager && iConfigManager->IsAutoFocusSupported() )
+{
+PlaySound( ECamAutoFocusFailed, EFalse );
+}
+SetOperation( ECamFocusFailed );
+}
+iPendingAFRequest=0;
+iCurrentAFRequest=0;
+}
+else if( iCurrentAFRequest != iPendingAFRequest && iPendingAFRequest !=0
+&& !CurrentSceneHasForcedFocus()
+)
+{
+iCurrentAFRequest=iPendingAFRequest;
+iPendingAFRequest=0;
+TryAFRequest( iCurrentAFRequest );
+}
+else if( CurrentSceneHasForcedFocus() )
+{
+// Autofocus flags has to be reset in forced focus cases
+iPendingAFRequest=0;
+iCurrentAFRequest=0;
+}
+}
+break;
+// ---------------------------------
+case ECamCameraEventCancelAutofocus:
+{
+// Set iAFCancelInProgress to true so that we don't change the
+// reticule for the next focus successful/focus failed event.
+iAFCancelInProgress = ETrue;
+iCurrentAFRequest = ECamRequestCancelAutofocus;
+// fixed toolbar is used only with touch devices
+if ( !iCaptureRequested && IsTouchScreenSupported() )
+{
+appUi->SetToolbarVisibility();  // avoid flickering in settings view
+}
+}
+break;
+// =================================
+default:
+// No change to state with other events
+break;
+// =================================
+}
+PRINT2( _L("Camera <= CCamAppController::SetStateFromEvent mode[%s] operation[%s]"),
+KCamModeNames[iInfo.iMode],
+KCamCaptureOperationNames[iInfo.iOperation] );
+}
+void
+CCamAppController::InitCaptureLimitL()
+{
+// Set the capture count now, so we don't need to set it when starting capture.
+switch( iInfo.iTargetImageMode )
+{
+case ECamImageCaptureBurst:
+PRINT1( _L("Camera <> CCamAppController .. burst mode as target, set capture limit to %d"), KShortBurstCount );
+SetCaptureLimitL( KShortBurstCount );
+break;
+case ECamImageCaptureTimeLapse:
+PRINT1( _L("Camera <> CCamAppController .. timelapse mode as target, set capture limit locally to max %d"), iLongSequenceLimit );
+SetCaptureLimitL( iLongSequenceLimit );
+break;
+default:
+PRINT( _L("Camera <> CCamAppController .. single mode as target, set capture limit locally to 1") );
+SetCaptureLimitL( 1 );
+break;
+}
+}
+// ===========================================================================
+//
+TCamAppControllerInfo::TCamAppControllerInfo()
+:  iActiveCamera         ( ECamActiveCameraNone ),
+iMode                 ( ECamControllerIdle   ),
+iTargetMode           ( ECamControllerIdle   ),
+iImageMode            ( ECamImageCaptureNone ),
+iTargetImageMode      ( ECamImageCaptureNone ),
+iOperation            ( ECamNoOperation      ),
+iTargetVfState        ( ECamTriIdle          ),
+iViewfinderMirror     ( EFalse               ),
+iTargetImageResolution( 0                    ),
+iTargetImageQuality   ( 0                    ),
+iBusyRequestId        ( ECamRequestNone      )
+{
+}
+// ===========================================================================
+//
+//
+//
+void CCamAppController::HandleFileHarvestingComplete()
+{
+PRINT( _L("Camera => CCamAppController::HandleFileHarvestingComplete" ) );
+// If release required but not done in postcapture not shown mode this is the
+	// last time to do it. Otherwise problems occurs in 2ndary camera if opened
+if ( iPendingRelease && ECamSettOff == IntegerSettingValue( ECamSettingItemShowCapturedPhoto ) )
+{
+PRINT( _L("Camera <> CCamAppController::HandleFileHarvestingComplete, releasing" ) );
+ReleaseCamera();
+}
+PRINT( _L("Camera <= CCamAppController::HandleFileHarvestingComplete" ) );
+}
+//
+//CCamAppController::DeRegisterHarverterClientEvents
+//
+void CCamAppController::DeRegisterHarverterClientEvents()
+{
+if ( iImageSaveActive )
+{
+#if defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)
+iImageSaveActive->DeRegisterHarverterClientEvents();
+#endif //defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::Configuration
+//
+// ---------------------------------------------------------------------------
+//
+CCamConfiguration*
+CCamAppController::Configuration() const
+{
+return iConfiguration;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RestoreSettingsToCameraL
+// Calls RestoreSettingIfNecessaryL for all supported camera settings.
+// In case there were settings needing restoring, and camera controller
+// is not busy, request camera controller to start setting changes.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::RestoreSettingsToCameraL()
+{
+PRINT( _L("Camera => CCamAppController::RestoreSettingsToCameraL" ) );
+const TCamCameraMode mode = CurrentMode();
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+if ( IsAppUiAvailable() && appUi->CurrentViewState()==ECamViewStateUserSceneSetup )
+{
+//restore user scence setting
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneWhitebalance );
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneExposure );
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneFlash );
+if ( UiConfigManagerPtr()->IsColorToneFeatureSupported() )
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneColourFilter );
+if ( UiConfigManagerPtr()->IsBrightnessSupported() )
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneBrightness );
+if ( UiConfigManagerPtr()->IsContrastSupported() )
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneContrast );
+if ( UiConfigManagerPtr()->IsISOSupported() || UiConfigManagerPtr()->IsExtendedLightSensitivitySupported() )
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneLightSensitivity );
+if ( ECamControllerImage == mode )
+{
+if ( UiConfigManagerPtr()->IsSharpnessFeatureSupported() )
+DirectRestoreSettingIfNecessaryL( ECamSettingItemUserSceneImageSharpness );
+DirectRestoreSettingIfNecessaryL( ECamSettingItemPhotoDigitalZoom );
+}
+else if ( ECamControllerVideo == mode )
+{
+DirectRestoreSettingIfNecessaryL( ECamSettingItemVideoDigitalZoom );
+DirectRestoreSettingIfNecessaryL( ECamSettingItemVideoStab);
+}
+}
+else if(iInfo.iActiveCamera == ECamActiveCameraPrimary)
+	    {
+if ( ECamControllerImage == mode )
+	        {
+	        // Add rest of the pending settings where needed
+	        RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoWhiteBalance );
+	        RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoExposure );
+	        if ( UiConfigManagerPtr()->IsColorToneFeatureSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoColourFilter );
+	        if ( UiConfigManagerPtr()->IsBrightnessSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoBrightness );
+	        if ( UiConfigManagerPtr()->IsContrastSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoContrast );
+	        if ( UiConfigManagerPtr()->IsSharpnessFeatureSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoImageSharpness );
+	        if ( UiConfigManagerPtr()->IsISOSupported() || UiConfigManagerPtr()->IsExtendedLightSensitivitySupported() )
+	            {
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoLightSensitivity );
+	            }
+	        RestoreSettingIfNecessaryL( ECamSettingItemDynamicPhotoFlash );
+	        RestoreSettingIfNecessaryL( ECamSettingItemPhotoDigitalZoom );
+	        }
+	    else if ( ECamControllerVideo == mode )
+	        {
+	        // Video settings in the toolbar
+	        RestoreSettingIfNecessaryL( ECamSettingItemDynamicVideoWhiteBalance );
+	        RestoreSettingIfNecessaryL( ECamSettingItemDynamicVideoExposure );
+	        if ( UiConfigManagerPtr()->IsColorToneFeatureSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicVideoColourFilter );
+	        // The following settings are not supported in video mode toolbar
+	        // However, the values may need to be reset, in case the setting was
+	        // changed in image mode
+	        if ( UiConfigManagerPtr()->IsBrightnessSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicVideoBrightness );
+	        if ( UiConfigManagerPtr()->IsContrastSupported() )
+	            RestoreSettingIfNecessaryL( ECamSettingItemDynamicVideoContrast );
+	        if ( UiConfigManagerPtr()->IsVideoStabilizationSupported() )
+	            {
+	            RestoreSettingIfNecessaryL( ECamSettingItemVideoStab );
+	            }
+	        RestoreSettingIfNecessaryL( ECamSettingItemVideoDigitalZoom );
+	        RestoreSettingIfNecessaryL( ECamSettingItemDynamicVideoFlash );
+	        RestoreSettingIfNecessaryL( ECamSettingItemContinuousAutofocus );
+	        }
+	    }
+else if(iInfo.iActiveCamera == ECamActiveCameraSecondary)
+{
+if ( ECamControllerImage == mode )
+{
+// Not needed
+}
+else if ( ECamControllerVideo == mode )
+{
+// Not needed
+}
+}
+else
+{
+// Do nothing
+}
+if( iSettingProvider->PendingSettingChangeCount() > 0 &&
+!iCameraController->ControllerInfo().iBusy )
+{
+PRINT( _L("Camera <> CCamAppController::RestoreSettingsToCameraL - Issue settings change request") );
+IssueSettingsChangeRequestL( );
+}
+PRINT( _L("Camera <= CCamAppController::RestoreSettingsToCameraL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RestoreSettingIfNecessaryL
+// Checks from camera controller, whether the value of the setting given
+// as argument has same value in camera hw and settings model (UI).
+// If value is not the same, add the setting id to settingsmodel's list
+// of pending changes.
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::RestoreSettingIfNecessaryL( TCamSettingItemIds aSettingItem )
+{
+// Convert UI setting ID to camera controller setting ID
+TCamCameraSettingId camSettingId =
+CCamSettingConversion::Map2CameraControllerSettingId( aSettingItem );
+if( !iCameraController->SettingValueUpToDateL( camSettingId ) )
+{
+PRINT1( _L("RestoreSettingIfNecessaryL - Restoring value for setting %s"), KCamSettingItemNames[aSettingItem] );
+iSettingProvider->AddPendingSettingChangeL( aSettingItem );
+}
+else
+{
+if( aSettingItem == ECamSettingItemDynamicVideoFlash )
+{
+TCamCameraSettingId cameraId(
+CCamSettingConversion::Map2CameraControllerSettingId( aSettingItem ) );
+iCameraController->DirectSettingsChangeL( cameraId );
+}
+PRINT1( _L("RestoreSettingIfNecessaryL - Setting %s has up-to-date value, no need to restore"), KCamSettingItemNames[aSettingItem] );
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DirectRestoreSettingIfNecessaryL
+// Checks if the setting needs restoring (UI setting value doesn't match
+// the actual setting value in camera).  In that case, function
+// directly set settting to camera
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::DirectRestoreSettingIfNecessaryL( TCamSettingItemIds aSettingItem )
+{
+TCamCameraSettingId cameraId(
+CCamSettingConversion::Map2CameraControllerSettingId( aSettingItem ) );
+if ( !iCameraController->SettingValueUpToDateL( cameraId ) )
+{
+PRINT1( _L("RestoreSettingIfNecessaryL - Restoring value for setting %s"), KCamSettingItemNames[aSettingItem] );
+iCameraController->DirectSettingsChangeL( cameraId );
+}
+}
+// -----------------------------------------------------------------------------
+// CCamAppController::RestartTimeLapseTimerL()
+//
+// -----------------------------------------------------------------------------
+//
+void CCamAppController::RestartTimeLapseTimerL()
+	{
+	PRINT( _L("Camera => CCamAppController::RestartTimeLapseTimerL inside this function" ))
+	if ( iTimeLapseTimer )
+		{
+		iTimeLapseTimer->Cancel();
+		iTimeLapseTimer->SetTimeout( KSecondInMicSec );
+		}
+else
+{
+iTimeLapseTimer = CCamTimer::NewL( KSecondInMicSec, TCallBack( CCamAppController::TimeLapseTimeoutL, this ) );
+}
+NotifyControllerObservers( ECamEventCounterUpdated );
+PRINT( _L("Camera <> CCamAppController::RestartTimeLapseTimerL starting timelapse timer" ));
+iTimeLapseStartTime.HomeTime();
+iTimeLapseTimer->StartTimer();
+	// Following trace may be useful to see timing related handling in TimeLapse mode
+	// TDateTime stTime = iTimeLapseStartTime.DateTime();
+	// PRINT3( _L("Start time: %d:%d:%d"), stTime.Minute(), stTime.Second(), stTime.MicroSecond() );
+	PRINT( _L("Camera <= CCamAppController::RestartTimeLapseTimerL" ))
+	}
+// ---------------------------------------------------------------------------
+// SetSettingsRestoreNeeded
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetSettingsRestoreNeeded()
+{
+iSettingsRestoreNeeded = ETrue;
+}
+// ---------------------------------------------------------------------------
+// IsSettingsRestoreNeeded
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::IsSettingsRestoreNeeded() const
+{
+return iSettingsRestoreNeeded;
+}
+// ---------------------------------------------------------------------------
+// StaticSettingsModel
+//
+// Gets the handle to the settings model, which is used inturn by the
+// plugin to call the interfaces for performing needed actions.
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::IsSceneSupported( const TInt aSceneId, TBool aPhotoScene ) const
+{
+if ( aPhotoScene )
+return static_cast<CCamSettingsModel*>(iSettingsModel)->IsImageSceneSupported( aSceneId );
+else
+return static_cast<CCamSettingsModel*>(iSettingsModel)->IsVideoSceneSupported( aSceneId );
+}
+// ---------------------------------------------------------------------------
+// StaticSettingsModel
+//
+// Gets the handle to the settings model, which is used inturn by the
+// plugin to call the interfaces for performing needed actions.
+// ---------------------------------------------------------------------------
+//
+MCamStaticSettings&
+CCamAppController::StaticSettingsModel()
+{
+return static_cast<CCamSettingsModel*>(iSettingsModel)->StaticSettingsModel();
+}
+// ---------------------------------------------------------------------------
+// EngineRequestsPending
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::EngineRequestsPending() const
+{
+return IsFlagOn( iBusyFlags, EBusyRequest );
+}
+// ---------------------------------------------------------------------------
+// CalculateVideoTimeRemainingL
+//
+// ---------------------------------------------------------------------------
+//
+TTimeIntervalMicroSeconds
+CCamAppController::CalculateVideoTimeRemainingL(const TCamMediaStorage aStorage)
+{
+RFs& fs = CEikonEnv::Static()->FsSession();
+TInt drive = 0;
+if(aStorage == ECamMediaStorageCurrent)
+	{
+const TDesC& filename = CurrentVideoFileName();
+TParse fp;
+User::LeaveIfError(fs.Parse(filename, fp));
+TPtrC driveletter = fp.Drive();
+TChar drl = driveletter[0];
+User::LeaveIfError(fs.CharToDrive(drl, drive));
+	}
+else
+	{
+	DriveInfo::TDefaultDrives driveInfo = static_cast<DriveInfo::TDefaultDrives>(KErrNotFound);
+	switch(aStorage)
+		{
+		case ECamMediaStoragePhone:
+			driveInfo = DriveInfo::EDefaultPhoneMemory;
+			break;
+		case ECamMediaStorageCard:
+			driveInfo = DriveInfo::EDefaultRemovableMassStorage;
+			break;
+		case ECamMediaStorageMassStorage:
+			driveInfo = DriveInfo::EDefaultMassStorage;
+			break;
+		default:
+			break;
+		}
+	User::LeaveIfError(DriveInfo::GetDefaultDrive( driveInfo, drive ));
+	}
+// Get critical level for this drive type
+TDriveInfo driveInfo;
+fs.Drive(driveInfo, drive);
+TInt criticalDiskVal = 0;
+if( driveInfo.iType == EMediaRam ) //RAM drives have diff critical levels
+	{
+	CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );
+	User::LeaveIfError(
+		repository->Get( KRamDiskCriticalLevel, criticalDiskVal ) );
+	CleanupStack::PopAndDestroy( repository );
+	}
+else // Some other media type
+	{
+	CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );
+	User::LeaveIfError(
+		repository->Get( KDiskCriticalThreshold, criticalDiskVal ) );
+	CleanupStack::PopAndDestroy( repository );
+	}
+// Get the available space in volumeinfo.iFree
+TVolumeInfo volumeinfo;
+User::LeaveIfError(fs.Volume(volumeinfo, drive));
+// Get the current video quality data
+TInt videoQuality = iSettingsModel->IntegerSettingValue(
+										ECamSettingItemVideoQuality );
+CCamVideoQualityLevel& level = *( iSettingsModel->
+									VideoQualityArray() )[videoQuality];
+// Audio recording on/muted
+TInt audioRec = iSettingsModel->IntegerSettingValue(
+									ECamSettingItemVideoAudioRec );
+TBool audioMute = ECamSettOff == audioRec;
+// Video file size limit (MMS case)
+TInt videoLimit = 0;
+if( ECamVideoClipShort == level.VideoLength() )
+{
+// Short video, needs to fit into MMS message
+videoLimit = CamUtility::MaxMmsSizeInBytesL();
+}
+TCamVideoTime videoTime( volumeinfo.iFree,            // Free space
+criticalDiskVal,             // Critical space
+//level.VideoFileType(),       // Video codec
+level.VideoBitRate(),        // Video bitrate
+//level.AudioType(),           // Audio FourCC
+level.AudioBitRate(),        // Audio bitrate
+videoLimit,                  // File size limit
+audioMute,                   // Mute audio?
+iConfiguration->CMRAvgVideoBitRateScaler() );
+return videoTime.GetRemainingTimeL();
+}
+// ---------------------------------------------------------------------------
+// SetRemainingImageStored
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::SetRemainingImageStored()
+{
+iValueIsStored = ETrue;
+}
+// ---------------------------------------------------------------------------
+// IsRemainingImageStored
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::IsRemainingImageStored() const
+{
+return iValueIsStored;
+}
+// ---------------------------------------------------------------------------
+// IsSavingInProgress
+// ---------------------------------------------------------------------------
+//
+TBool
+CCamAppController::IsSavingInProgress() const
+{
+return ( iImageSaveActive->Count() > 0 );
+}
+// ---------------------------------------------------------------------------
+// CapturedImages
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::CapturedImages() const
+{
+return iCameraController->ControllerInfo().iCaptureCount;
+}
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CCamAppController::SetSettingsPlugin( CCamGSInterface* aPlugin )
+	{
+	iPlugin = aPlugin;
+	}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetViewfinderWindowHandle
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetViewfinderWindowHandle( RWindowBase* aWindow )
+{
+__ASSERT_ALWAYS( iCameraController, CamPanic( ECamPanicInvalidState ) );
+iCameraController->SetViewfinderWindowHandle( aWindow );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ViewfinderWindowDeleted
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::ViewfinderWindowDeleted( RWindowBase* aWindow )
+{
+__ASSERT_ALWAYS( iCameraController, CamPanic( ECamPanicInvalidState ) );
+iCameraController->ViewfinderWindowDeleted( aWindow );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::ExistMassStorage()
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::ExistMassStorage() const
+{
+const TUint KMassStorageBits = DriveInfo::EDriveInternal |
+DriveInfo::EDriveExternallyMountable;
+TInt drive;
+TInt err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive );
+if ( err != KErrNone )
+{
+return EFalse;
+}
+TUint driveStatus(0);
+err = DriveInfo::GetDriveStatus( CCoeEnv::Static()->FsSession(),
+drive,
+driveStatus );
+TInt usbPersonality;
+TInt ret = RProperty::Get(KPSUidUsbWatcher,
+						  KUsbWatcherSelectedPersonality,
+						  usbPersonality);
+if ( err != KErrNone )
+{
+return EFalse;
+}
+if ( (driveStatus & KMassStorageBits) == KMassStorageBits &&
+		 !(driveStatus & DriveInfo::EDriveCorrupt) &&
+	((KErrNone == ret) && (KUsbPersonalityIdMS != usbPersonality) ) )
+{
+return ETrue;
+}
+return EFalse;
+}
+// ------------------------------------------------------------------------
+// CCamAppController::IsMemoryAvailable()
+// ------------------------------------------------------------------------
+//
+TBool
+CCamAppController::IsMemoryAvailable(const TCamMediaStorage aStorage, TBool aIgnoreUsbPersonality ) const
+	{
+	TInt currentStorage = aStorage;
+	if(aStorage == ECamMediaStorageCurrent)
+		{
+		TCamCameraMode mode = CurrentMode();
+		if((ECamControllerImage != mode) && (ECamControllerVideo != mode))
+{
+//This is needed for case where current mode is not yet set.
+mode = TargetMode();
+}
+		if(ECamControllerImage == mode)
+			{
+			currentStorage = static_cast<TCamMediaStorage>(
+								IntegerSettingValue(
+									ECamSettingItemPhotoMediaStorage ) );
+			}
+		else if(ECamControllerVideo == mode)
+			{
+			currentStorage = static_cast<TCamMediaStorage>(
+								IntegerSettingValue(
+									ECamSettingItemVideoMediaStorage ) );
+			}
+		else
+			{
+			//No impl
+			}
+		}
+	TInt usbPersonality;
+	TInt ret = RProperty::Get(KPSUidUsbWatcher,
+							  KUsbWatcherSelectedPersonality,
+							  usbPersonality);
+if ( !aIgnoreUsbPersonality )
+{
+if ( ( currentStorage != ECamMediaStoragePhone ) && ( KErrNone == ret ) &&
+( KUsbPersonalityIdMS == usbPersonality ) )
+{
+return EFalse;
+}
+}
+	DriveInfo::TDefaultDrives driveInfo = static_cast<DriveInfo::TDefaultDrives>(KErrNotFound);
+	switch(currentStorage)
+		{
+		case ECamMediaStoragePhone:
+			driveInfo = DriveInfo::EDefaultPhoneMemory;
+			break;
+		case ECamMediaStorageCard:
+			driveInfo = DriveInfo::EDefaultRemovableMassStorage;
+			break;
+		case ECamMediaStorageMassStorage:
+			driveInfo = DriveInfo::EDefaultMassStorage;
+			break;
+		default:
+			break;
+		}
+	TInt drive;
+	TInt err = DriveInfo::GetDefaultDrive( driveInfo, drive );
+	if(err)
+		{
+		return EFalse;
+		}
+TUint driveStatus(0);
+err = DriveInfo::GetDriveStatus( CCoeEnv::Static()->FsSession(),
+drive,
+driveStatus );
+if(err)
+	{
+	return EFalse;
+	}
+return ( (driveStatus & DriveInfo::EDrivePresent) &&
+		   !(driveStatus & DriveInfo::EDriveCorrupt) &&
+	       (driveStatus & DriveInfo::EDriveUserVisible) &&
+	       !(driveStatus & DriveInfo::EDriveInUse) &&
+	       !(driveStatus & DriveInfo::EDriveReadOnly) );
+	}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsDemandKeyRelease()
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsDemandKeyRelease()
+{
+return iDemandKeyRelease;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetDemandKeyRelease()
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetDemandKeyRelease( TBool aDemand )
+{
+iDemandKeyRelease = aDemand;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsKeyLockOn()
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsKeyLockOn()
+{
+if ( iKeyLockStatusWatcher && iConfigManager && iConfigManager->IsKeyLockWatcherSupported() )
+{
+CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+TInt iKeyLockStatus = 0;
+iKeyLockStatusWatcher->Get( iKeyLockStatus );
+if ( iKeyLockStatus == EKeyguardLocked && appUi )
+{
+return ETrue;
+}
+else
+{
+return EFalse;
+}
+}
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DriveChangeL
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::DriveChangeL( const TCamDriveChangeType aType )
+{
+PRINT1( _L("Camera => CCamAppController::DriveChangeL aType: %d" ), aType );
+TCamCameraMode mode = CurrentMode();
+TCamMediaStorage currentStorage;
+// Photos and videos are saved onto the same media, so no need to
+// differentiate between still/video
+currentStorage = static_cast<TCamMediaStorage>(
+IntegerSettingValueUnfiltered( ECamSettingItemPhotoMediaStorage ) );
+PRINT1( _L("Camera <> iPreferredStorageLocation is now %d"),
+iPreferredStorageLocation );
+PRINT1( _L("Camera <> Update iPreferredStorageLocation to %d"),
+currentStorage );
+iPreferredStorageLocation = currentStorage;
+if ( ECamMediaStoragePhone == iPreferredStorageLocation )
+{
+PRINT( _L("Camera <> Phone memory is the preferred storage location. Nothing to be done here. Return KErrNone.") )
+PRINT( _L("Camera <= CCamAppController::DriveChangeL" ) );
+return KErrNone;
+}
+if  ( ( !IsMemoryAvailable( ECamMediaStorageCard, EFalse ) ||
+!IsMemoryAvailable( ECamMediaStorageMassStorage, EFalse ) ) ||
+!IsMemoryAvailable( iPreferredStorageLocation, ETrue ) )
+{
+PRINT( _L("Camera <> USB personality is 'Mass storage' or iPreferredStorageLocation (MMC or mass memory) is unavailable") )
+// Stop if recording a video to mass memory or MMC
+if ( CurrentVideoOperation() == ECamCapturing ||
+CurrentVideoOperation() == ECamPaused )
+{
+PRINT( _L("Camera <> Video capture in progress...") )
+if ( !IsMemoryAvailable( iInitialVideoStorageLocation ) )
+{
+PRINT( _L("Camera <> ...Stop  video recording.") )
+iCaptureStoppedForUsb = ETrue;
+StopVideoRecording();
+}
+else
+{
+PRINT( _L("Camera <> ...Phone memory in use. No need to stop.") )
+}
+}
+// Cancel if pending recording
+else if( iVideoRequested )
+{
+iVideoRequested = EFalse;
+}
+if ( SequenceCaptureInProgress() )
+{
+PRINT( _L("Camera <> Sequence capture in progress. -> Stop and skip postcapture.") )
+iCaptureStoppedForUsb = ETrue;
+SoftStopBurstL( ETrue );
+}
+// If in the middle of init sequence or saving a file, set the dismount
+// pending so that the AllowDismount call will be made later
+if( IsFlagOn( iBusyFlags, EBusySequence ) || iSaving )
+{
+PRINT( _L("Camera <> CCamAppController::DriveChangeL sequence or saving ongoing" ) );
+iDismountPending = ETrue;
+// Mass memory may be the forced storage location. Then it's necessary
+// to switch to (forced) phone memory
+ForceUsePhoneMemoryL( ETrue );
+PRINT( _L("Camera <= CCamAppController::DriveChangeL dismount pending" ) );
+return KErrNotReady;
+}
+else
+{
+// Mass memory may be the forced storage location. Then it's necessary
+// to switch to (forced) phone memory
+ForceUsePhoneMemoryL( ETrue );
+// Make sure toolbar is visible
+CCamAppUi* appUi = static_cast<CCamAppUi*>(
+CEikonEnv::Static()->AppUi() );
+CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();
+if ( fixedToolbar && ECamNoOperation == CurrentOperation() )
+{
+fixedToolbar->SetToolbarVisibility( ETrue );
+}
+PRINT( _L("Camera <= CCamAppController::DriveChangeL dismount ok" ) );
+return KErrNone;
+}
+}
+else if ( IsMemoryAvailable( iPreferredStorageLocation, ETrue ) &&
+( ECamMediaStorageCard == iPreferredStorageLocation ||
+ECamMediaStorageMassStorage  == iPreferredStorageLocation ) )
+{
+PRINT( _L("Camera <> iPreferredStorageLocation (MMC or mass memory) is now available.") )
+// if phone memory forced, then revert back to user selected location
+if ( iForceUseOfPhoneMemory )
+{
+PRINT( _L("Camera <> Phone memory is forced, switch back to user selected storage location.") )
+ForceUsePhoneMemoryL( EFalse );
+}
+else
+{
+PRINT( _L("Camera <> !IsPhoneMemoryForced() -> No action.") )
+}
+}
+PRINT( _L("Camera <= CCamAppController::DriveChangeL" ) );
+return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentStorage
+// ---------------------------------------------------------------------------
+//
+TCamMediaStorage CCamAppController::CurrentStorage()
+{
+return iCurrentStorage;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsAfNeeded
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsAfNeeded()
+{
+return iAfNeeded;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetAfNeeded
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetAfNeeded( TBool aAfNeeded )
+{
+iAfNeeded = aAfNeeded;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsCaptureStoppedForUsb
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsCaptureStoppedForUsb()
+{
+return iCaptureStoppedForUsb;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetCaptureStoppedForUsb
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetCaptureStoppedForUsb( TBool aCaptureStoppedForUsb )
+{
+iCaptureStoppedForUsb = aCaptureStoppedForUsb;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CancelDismountMonitoring
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CancelDismountMonitoring()
+{
+if( iDriveChangeNotifier )
+{
+iDriveChangeNotifier->CancelMonitoring();
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StartDismountMonitoring
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StartDismountMonitoring()
+{
+if( iDriveChangeNotifier )
+{
+iDriveChangeNotifier->StartMonitoring();
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DeepSleepTimeout
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::DeepSleepTimeout( TAny* aPtr )
+{
+static_cast<CCamAppController*>( aPtr )->DoDeepSleepTimeout();
+return EFalse; // dummy
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DoDeepSleepTimeout
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DoDeepSleepTimeout()
+{
+PRINT( _L("Camera => CCamAppController::DoDeepSleepTimeout") );
+ReleaseCamera();
+iDeepSleepTimerExpired = ETrue;
+iDeepSleepTimer->Cancel();
+PRINT( _L("Camera <= CCamAppController::DoDeepSleepTimeout") );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DeepSleepTimerStart
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DeepSleepTimerStart()
+{
+PRINT( _L("Camera : DeepSleepTimerStart") );
+iDeepSleepTimerExpired = EFalse;
+if ( iDeepSleepTimer && !iDeepSleepTimer->IsActive() )
+{
+iDeepSleepTimer->StartTimer();
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::DeepSleepTimerCancel
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::DeepSleepTimerCancel()
+{
+PRINT( _L("Camera : DeepSleepTimerCancel") );
+if ( iDeepSleepTimer )
+{
+iDeepSleepTimer->Cancel();
+}
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::AllSnapshotsReceived
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::AllSnapshotsReceived()
+{
+PRINT1( _L("Camera <> AllSnapshotsReceived %d"), iAllSnapshotsReceived );
+return iAllSnapshotsReceived;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::PendingAFRequest
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::PendingAFRequest()
+{
+return iPendingAFRequest;
+}
+// CCamAppController::IsTouchScreenSupported
+// Return whether the device supports touch screen
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsTouchScreenSupported()
+{
+return AknLayoutUtils::PenEnabled();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::IsTouchScreenSupported
+// Return whether the device supports direct screen viewfinder
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::IsDirectScreenVFSupported( TBool aPrimaryCamera )
+{
+// test for integration
+return iConfigManager->IsDSAViewFinderSupported( aPrimaryCamera );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::UiConfigManagerPtr
+// handle  to CameraUiConfigManager
+// ---------------------------------------------------------------------------
+//
+CCameraUiConfigManager* CCamAppController::UiConfigManagerPtr()
+{
+	__ASSERT_DEBUG(iConfigManager, CamPanic(ECamPanicNullPointer));
+return iConfigManager;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetCameraOrientationModeL
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetCameraOrientationModeL( TInt aOrientation )
+{
+iCameraController->SetOrientationModeL( aOrientation );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CompleteCameraConstruction
+//
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::CompleteCameraConstructionL()
+{
+PRINT( _L( "Camera => CCamAppController::CompleteCameraConstructionL" ) );
+iCameraController->CompleteSwitchCameraL();
+// start reserve and poweron already here
+IssueModeChangeSequenceL( ETrue );
+PRINT( _L( "Camera <= CCamAppController::CompleteCameraConstructionL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::CurrentImageIndex
+//
+// ---------------------------------------------------------------------------
+//
+TInt CCamAppController::CurrentImageIndex()
+{
+return iCurrentImageIndex;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamAppController::GenerateStartupSequenceL( RCamRequestArray& aSequence )
+{
+PRINT( _L( "Camera => CCamAppController::GenerateStartupSequenceL" ) );
+//Have to empty autofocusrequest values here because modechange could override
+//currently processed autofocus request.
+iPendingAFRequest=0;
+iCurrentAFRequest=0;
+iNoBurstCancel = EFalse;
+iKeyUP = EFalse;
+aSequence.Append( ECamRequestReserve );
+aSequence.Append( ECamRequestPowerOn );
+// -------------------------------------------------------
+#ifdef _DEBUG
+PRINT( _L( "Camera <> Generated sequence: " ) );
+for( TInt i = 0; i < aSequence.Count(); i++ )
+{
+PRINT2( _L( "Camera <> %d) %s" ), i, KCamRequestNames[aSequence[i]] );
+}
+#endif
+PRINT( _L( "Camera <= CCamAppController::GenerateStartupSequenceL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RotateSnapshotL
+// Copy and rotate snapshot bitmap before it is used to
+// create a thumbnail
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::RotateSnapshotL()
+{
+PRINT( _L( "Camera => CCamAppController::RotateSnapshotL" ) );
+// empty the array
+if( iRotationArray->Count() > 0 )
+{
+iRotationArray->Reset();
+}
+// copy snapshot to preserve the original snapshot bitmap
+// first get the handle for the original snapshot bitmap
+CFbsBitmap* snapshot = new (ELeave)CFbsBitmap();
+CleanupStack::PushL( snapshot );
+snapshot->Duplicate( BurstCaptureArray()->Snapshot( iCurrentImageIndex )->Handle() );
+//create a new bitmap with the same dimensions as the original snapshot
+iRotatedSnapshot = new (ELeave)CFbsBitmap();
+iRotatedSnapshot->Create( snapshot->SizeInPixels(), snapshot->DisplayMode() );
+TRect tmpRect( TPoint( 0, 0 ), snapshot->SizeInPixels() );
+TInt tmpLen = tmpRect.Width() * tmpRect.Height() * 4;
+//copy the snapshot data
+iRotatedSnapshot->BeginDataAccess();
+snapshot->BeginDataAccess();
+Mem::Copy( iRotatedSnapshot->DataAddress(), snapshot->DataAddress(), tmpLen );
+iRotatedSnapshot->EndDataAccess();
+snapshot->EndDataAccess();
+// copy the filename
+iRotationArray->SetNextNameL( BurstCaptureArray()->FileName( iCurrentImageIndex ), BurstCaptureArray()->ImageName( iCurrentImageIndex ));
+// rotate the copied snapshot
+if ( !iRotatorAo )
+{
+iRotatorAo = CCamSyncRotatorAo::NewL( *this );
+}
+iRotatorAo->RotateL( iRotatedSnapshot, MapCamOrientation2RotationAngle( iCaptureOrientation ) );
+CleanupStack::Pop( snapshot );
+PRINT( _L( "Camera <= CCamAppController::RotateSnapshotL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::RotationCompleteL
+// Notification of bitmap rotation complete events
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::RotationCompleteL( TInt aErr )
+{
+PRINT1( _L( "Camera => CCamAppController::RotationCompleteL aErr:%d" ), aErr );
+// rotation completed, use the rotated bitmap to create a thumbnail
+// in case of error, don't use the snapshot, thumbnail is created from
+// the imagefile instead
+if ( !aErr )
+{
+iRotationArray->ReplaceSnapshot( iRotatedSnapshot, 0 );
+}
+TRAP_IGNORE( iImageSaveActive->CreateThumbnailsL( *iRotationArray ) );
+PRINT( _L( "Camera <= CCamAppController::RotationCompleteL" ) );
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::StoreFaceTrackingValue
+// Calls CamSettingModel to save user defined FT setting
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::StoreFaceTrackingValue()
+{
+iSettingsModel->StoreFaceTrackingValue();
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::SetVideoInitNeeded
+// Sets the value defining the need for CAE video init and prepare
+// ---------------------------------------------------------------------------
+//
+void CCamAppController::SetVideoInitNeeded( TBool aVideoInitNeeded )
+{
+iVideoInitNeeded = aVideoInitNeeded;
+}
+// ---------------------------------------------------------------------------
+// CCamAppController::VideoInitNeeded
+// Returns the value defining the need for CAE video init and prepare
+// ---------------------------------------------------------------------------
+//
+TBool CCamAppController::VideoInitNeeded()
+{
+return iVideoInitNeeded;
+}
+//  End of File

changeset 0	1ddebce53859
child 1	f5ec9446e5bf