--- a/camerauis/cameraapp/generic/src/CamAppController.cpp Tue Feb 02 00:01:39 2010 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,10929 +0,0 @@
-/*
-* Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of "Eclipse Public License v1.0"
-* which accompanies this distribution, and is available
-* at the URL "http://www.eclipse.org/legal/epl-v10.html".
-*
-* 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 <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 "camsnapshotrotator.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;
- }
-
- delete iSnapShotRotator;
- 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() );
-
- if ( iSnapShotRotator->IsActive() )
- {
- // Avoid flickering. Do not show original snapshot, if it needs to be rotated
- PRINT( _L("Camera <= CCamAppController::SnapshotImage - return null") );
- return NULL;
- }
-
- //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 );
- iSnapShotRotator = CCamSnapShotRotator::NewL( *this );
- 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 ) );
-
- if( iInfo.iActiveCamera == ECamActiveCameraSecondary &&
- iCaptureOrientation == ECamOrientation90 &&
- ECamSettOn == IntegerSettingValue( ECamSettingItemShowCapturedPhoto ) )
- {
- PRINT( _L( "Camera <> Rotate portrait secondary camera snapshot image 180 degrees" ) )
- TRAP_IGNORE( iSnapShotRotator->RotateL( aBitmap ) );
- }
-
- 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 ) ||
- iInfo.iActiveCamera == ECamActiveCameraSecondary ) &&
- ECamSettOn == IntegerSettingValue( ECamSettingItemShowCapturedPhoto ) &&
- iCaptureOrientation != ECamOrientation0 );
-
- 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();
- iSettingsModel->StoreUserSceneSettingsL();
-
- 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 )
- || iInfo.iActiveCamera == ECamActiveCameraSecondary );
-
- 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 )
- {
- // Camera controller asks for the current orientation through
- // our ImageOrientation(). Value for that was updated in
- // DataReceived() callback.
- iCameraController->DirectSettingsChangeL( ECameraSettingOrientation );
- }
- 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
- || iInfo.iActiveCamera == ECamActiveCameraSecondary ) )
- )
- {
- 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, DUP7_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_APP_AF 0" );
- OstTrace0( CAMERAAPP_PERFORMANCE, DUP8_CCAMAPPCONTROLLER_HANDLECAMERAEVENTL, "e_CAM_PRI_AF_LOCK 0" );
- 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;
- }
-
-// ---------------------------------------------------------------------------
-// StoreUserSceneSettingsL
-// Stores the UserScene settings
-// ---------------------------------------------------------------------------
-//
-void CCamAppController::StoreUserSceneSettingsL()
- {
- iSettingsModel->StoreUserSceneSettingsL();
- }
-// End of File