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