diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamStillPreCaptureContainer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/src/CamStillPreCaptureContainer.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,1154 @@ +/* +* Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Container class for still image pre-capture view* +*/ + +// INCLUDE FILES +#include +#include + +#include +#include +#include +#include +#include + +#include "CamStillPreCaptureContainer.h" +#include "CamLogger.h" +#include "CamPreCaptureViewBase.h" +#include "CamAppUi.h" +#include "CamSidePane.h" +#include "CamSelfTimer.h" +#include "CamUtility.h" +#include "camactivepalettehandler.h" +#include "CameraUiConfigManager.h" +#include "OstTraceDefinitions.h" +#include "CamIndicator.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "CamStillPreCaptureContainerTraces.h" +#endif + +#include "camvfgridinterface.h" +#include "camlinevfgriddrawer.h" +#include "CamPanic.h" + +// Constants +const TUid KGridDrawerUid = { KCamLineDrawVfGridUid }; +const TInt KGridHrzLines = 2; +const TInt KGridVrtLines = 2; +const TInt KGridThickness = 2; +const TRgb KGridColor = KRgbGray; +const CGraphicsContext::TPenStyle KGridStyle = CGraphicsContext::ESolidPen; + +// ================= MEMBER FUNCTIONS ======================= + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::NewL +// Symbian OS two-phased constructor +// --------------------------------------------------------------------------- +// +CCamStillPreCaptureContainer* CCamStillPreCaptureContainer::NewL( + CCamAppController& aController, + CAknView& aView, + const TRect& aRect ) + { + CCamStillPreCaptureContainer* self = new( ELeave ) CCamStillPreCaptureContainer( + aController, aView ); + + CleanupStack::PushL( self ); + self->ConstructL( aRect ); + CleanupStack::Pop( self ); + // Return newly created CCamStillPreCaptureContainer instance + return self; + } + + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::~CCamStillPreCaptureContainer +// Destructor +// --------------------------------------------------------------------------- +// +CCamStillPreCaptureContainer::~CCamStillPreCaptureContainer() + { + PRINT( _L("Camera => ~CCamStillPreCaptureContainer" )) + + if ( iAPCreateAO ) + { + iAPCreateAO->Cancel(); + delete iAPCreateAO; + } + + if ( iXenonFlashSupported ) + { + // Unsubscribe blink events + if( CCamFlashStatus* flashStatus = iController.FlashStatus() ) + flashStatus->Subscribe( NULL ); + + delete iFlashBitmap; + delete iFlashBitmapMask; + } + PRINT( _L("Camera <= ~CCamStillPreCaptureContainer" )) + } + +// --------------------------------------------------------- +// CCamStillPreCaptureContainer::ConstructL +// Symbian OS 2nd phase constructor +// --------------------------------------------------------- +// +void CCamStillPreCaptureContainer::ConstructL( const TRect& aRect ) + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::ConstructL" )) + BaseConstructL( aRect ); + + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) + { + iAPCreateAO = CIdle::NewL(CActive::EPriorityStandard); + } + + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsAutoFocusSupported() ) + { + if( iController.IntegerSettingValue( ECamSettingItemPhotoShowFocusPoint ) ) + { + iShowReticule = EFalse; + } + else + { + iShowReticule = ETrue; + } + } + + iSidePane->SetCaptureMode( ECamControllerImage ); + + + iXenonFlashSupported = iController.UiConfigManagerPtr()->IsXenonFlashSupported(); + if ( iXenonFlashSupported ) + { + InitFlashIconL(); + LayoutFlashIcon(); + } + + PrepareProcessingTextL( ETrue ); + + if ( !( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) ) + { + OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTURECONTAINER_CONSTRUCTL, "e_CAM_APP_AP_SETUP 1" ); + static_cast( this ) + ->SetupActivePaletteL( static_cast(&iView) ); + OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTURECONTAINER_CONSTRUCTL, "e_CAM_APP_AP_SETUP 0" ); + } + + PRINT( _L("Camera <= CCamStillPreCaptureContainer::ConstructL" )) + } + +// --------------------------------------------------------- +// CCamContainerBase::BaseConstructL +// Symbian OS 2nd phase constructor +// --------------------------------------------------------- +// +void CCamStillPreCaptureContainer::BaseConstructL( const TRect& aRect ) + { + CCamPreCaptureContainerBase::BaseConstructL( aRect ); + // Layout the reticule. + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsAutoFocusSupported() ) + { + SizeChanged(); // Init layout + } + } + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::CCamStillPreCaptureContainer +// C++ constructor +// --------------------------------------------------------------------------- +// + +CCamStillPreCaptureContainer::CCamStillPreCaptureContainer( + CCamAppController& aController, + CAknView& aView ) +: CCamPreCaptureContainerBase( aController, aView ) + { + } + + +// --------------------------------------------------------- +// CCamStillPreCaptureContainer::HandleControllerEventL +// Receives notifications about changes in recording state from the controller +// --------------------------------------------------------- +// +void CCamStillPreCaptureContainer::HandleControllerEventL( TCamControllerEvent aEvent, TInt aError ) + { + PRINT1( _L("Camera => CCamStillPreCaptureContainer::HandleControllerEventL aEvent:%d" ), aEvent ) + CCamAppUi* appUi = static_cast(CEikonEnv::Static()->AppUi()); + + switch( aEvent ) + { + // --------------------------------------------------- + case ECamEventImageQualityChanged: + { + PRINT( _L("Camera <> CCamStillPreCaptureContainer - ECamEventImageQualityChanged") ); + // If our viewfinder area is already set and image quality changes, + // do re-layout. + if( !iRect.IsEmpty() ) + { + const TRect r( ViewFinderFrameRect() ); + if( iRect != r ) + { + PRINT( _L("Camera <> CCamStillPreCaptureContainer - doing re-layout..") ); + iRect = r; + SizeChanged(); + } + } + SetResolutionIndicator(); + break; + } + // --------------------------------------------------- + case ECamEventLocationSettingChanged: + { + // If the location setting was changed on, then the indicator should be visible + SetLocationIndicatorVisibility(); + break; + } + // --------------------------------------------------- + case ECamEventCameraChanged: + { + break; + } + // --------------------------------------------------- + case ECamEventOperationStateChanged: + { + if( ECamCapturing == iController.CurrentOperation() ) + { + // If capture has just begun, and it's burst capture, + // will need to set the softkeys to Blank/Cancel (via UpdateCbaL call) + if ( appUi->IsBurstEnabled() ) + { + // Burst *is* enabled, so force the update of the CBA + static_cast(iView).UpdateCbaL(); + } + else // if burst is not enabled show the saving image wait note + { + Window().Invalidate(); + } + } + else + { + } + break; + } + // --------------------------------------------------- + case ECamEventSetupStateChanged: + { + appUi->APHandler()->UpdateActivePaletteL(); + break; + } + // --------------------------------------------------- + case ECamEventEngineStateChanged: + { + if( iController.CurrentImageModeSetup() == ECamImageCaptureBurst && + !iController.SequenceCaptureInProgress() ) + { + // Burst mode - processing text needed + PrepareBurstProcessingTextL(); + } + break; + } + // --------------------------------------------------- + case ECamEventInitReady: + { + // event only received if UIOrientationOverride feature is supported + if( iAPCreateAO->IsActive() ) + { + iAPCreateAO->Cancel(); + } + iAPCreateAO->Start( TCallBack( BackgroundAPL,this ) ); + break; + } + // --------------------------------------------------- + default: + { + // otherwise, do nothing + break; + } + // --------------------------------------------------- + } + CCamPreCaptureContainerBase::HandleControllerEventL( aEvent, aError ); + PRINT( _L("Camera <= CCamStillPreCaptureContainer::HandleControllerEventL" ) ) + } + + +//---------------------------------------------- +// BackgroundAPL +// Create AP ItemActive object Callback +//---------------------------------------------- +TInt CCamStillPreCaptureContainer::BackgroundAPL( TAny *aparam ) + { + CCamStillPreCaptureContainer* camStillCaptureContainer = reinterpret_cast (aparam); + return camStillCaptureContainer->SetupActivePaletteCallbackL(); + } + + +//---------------------------------------------- +// SetupActivePaletteCallbackL +// Initializes ActivePalette +//---------------------------------------------- +TInt CCamStillPreCaptureContainer::SetupActivePaletteCallbackL() + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::SetupActivePaletteCallbackL" ) ) + CCamAppUi* appUi = static_cast(CEikonEnv::Static()->AppUi()); + if ( !iController.IsTouchScreenSupported() && + iController.CurrentMode()== ECamControllerImage ) + { + if ( appUi ) + { + appUi->SetActivePaletteVisibility( EFalse); + if ( !appUi->ActivePalette() ) + { + OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_SETUP 1" ); + static_cast( this ) + ->SetupActivePaletteL( static_cast(&iView) ); + OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_SETUP 0" ); + } + else + { + OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_UPDATE 1" ); + appUi->APHandler()->UpdateActivePaletteL(); + OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_UPDATE 0" ); + } + appUi->SetActivePaletteVisibility( ETrue ); + } + else + { + } + } + PRINT( _L("Camera <= CCamStillPreCaptureContainer::SetupActivePaletteCallbackL" ) ) + return EFalse; + } + +// --------------------------------------------------------- +// CCamStillPreCaptureContainer::OfferKeyEventL +// Handle key events +// --------------------------------------------------------- +// +TKeyResponse +CCamStillPreCaptureContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent, + TEventCode aType ) + { + // if the cancel softkey is pressed + + // If currently capturing a burst + if ( iController.SequenceCaptureInProgress() ) + { + if ( aKeyEvent.iScanCode == EStdKeyDevice1 ) + { + // Just return so the key press does not pass up to the base + // class This will now be handled in HandleCommandL() + return EKeyWasNotConsumed; + } + } + return CCamPreCaptureContainerBase::OfferKeyEventL( aKeyEvent, aType ); + } + +// --------------------------------------------------------- +// CCamStillPreCaptureContainer::ViewFinderLayoutResourceIds +// Return the layout resource id for the viewfinder +// --------------------------------------------------------- +// +void CCamStillPreCaptureContainer::ViewFinderLayoutResourceIds( + TInt& aViewFinderLayoutId, + TInt& aReticuleLayoutId ) const + { + { + aViewFinderLayoutId = ROID(R_CAM_VIEWFINDER_RECT_STILL_ID); + CCamAppUiBase* appui = static_cast( iEikonEnv->AppUi() ); + if ( appui->IsSecondCameraEnabled() ) + { + aViewFinderLayoutId = ROID(R_CAM_STILL_DISPLAYED_RECT_SECONDARY_ID); + } + } + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsAutoFocusSupported() ) + { + // set the layouts for the still capture viewfinder and reticule + aReticuleLayoutId = R_CAM_IMG_PRECAP_RETICULE; + } + else + { + aReticuleLayoutId = 0; + } + } + +// --------------------------------------------------------- +// CCamStillPreCaptureContainer::SetResolutionIndicator +// Sets the resolution indicator to the required icon +// --------------------------------------------------------- +// +void CCamStillPreCaptureContainer::SetResolutionIndicator() + { + // The setting stored is an index into the array of supported qualities, + // and since this matches the array of supported quality icons, we do + // not need to do any further lookup on this value. + iCurrentIndicator = iController.IntegerSettingValue( ECamSettingItemPhotoQuality ); + } + +// --------------------------------------------------------- +// CCamStillPreCaptureContainer::SetLocationIndicatorVisibility +// Sets the resolution indicator visibility, if it is set or not +// --------------------------------------------------------- +// +void CCamStillPreCaptureContainer::SetLocationIndicatorVisibility() + { + // The setting stored is an index of whether the location setting is on or off + iLocationIndicatorVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation )); + } + +// ---------------------------------------------------- +// CCamStillPreCaptureContainer::IncreaseFlashSettingL +// Move up through the flash settings +// ---------------------------------------------------- +// +void CCamStillPreCaptureContainer::IncreaseFlashSettingL() + { + if ( iZoomPane->IsVisible() + || static_cast( iEikonEnv->AppUi() )->IsSecondCameraEnabled() + ) + { + return; + } + // get current setting + TInt setting = + iController.IntegerSettingValue( ECamSettingItemDynamicPhotoFlash ); + + // Max/Min settings are ECamFlashAuto/ECamFlashOff + // and navi-key right moves down the list of settings + if ( setting == ECamFlashOff ) + { + setting = ECamFlashAuto; + } + else if ( setting >= ECamFlashAuto ) + { + setting++; + } + else + { + // remove Lint warning + } + + // only update if setting is invalid + if ( setting >= ECamFlashAuto && setting <= ECamFlashOff ) + { + iController.SetIntegerSettingValueL( + ECamSettingItemDynamicPhotoFlash, ( setting ) ); + } + } + +// ---------------------------------------------------- +// CCamStillPreCaptureContainer::DecreaseFlashSettingL +// Move down through the flash settings +// ---------------------------------------------------- +// +void CCamStillPreCaptureContainer::DecreaseFlashSettingL() + { + if ( iZoomPane->IsVisible() + || static_cast( iEikonEnv->AppUi() )->IsSecondCameraEnabled() + ) + { + return; + } + // get current setting + TInt setting = + iController.IntegerSettingValue( ECamSettingItemDynamicPhotoFlash ); + + // Max/Min settings are ECamFlashAuto/ECamFlashOff + // and navi-key left moves up the list of settings + if ( setting == ECamFlashAuto ) + { + setting = ECamFlashOff; + } + else if ( setting > ECamFlashAuto ) + { + setting--; + } + else + { + // remove Lint warning + } + + // only update if setting is invalid + if ( setting >= ECamFlashAuto && setting <= ECamFlashOff ) + { + iController.SetIntegerSettingValueL( + ECamSettingItemDynamicPhotoFlash, ( setting ) ); + } + } + +// ---------------------------------------------------- +// CCamStillPreCaptureContainer::HandleCaptureKeyEventL +// Change the current capture state +// ---------------------------------------------------- +// +TKeyResponse +CCamStillPreCaptureContainer::HandleCaptureKeyEventL( const TKeyEvent& aKeyEvent ) + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::HandleCaptureKeyEventL")) + TKeyResponse keyResponse = EKeyWasNotConsumed; + CCamAppUi* appui = static_cast( iEikonEnv->AppUi() ); + __ASSERT_DEBUG(appui, CamPanic(ECamPanicNullPointer)); + TBool MSKCapture(EFalse); + // First handle middle softkey and enter key capture event + if ( !appui->IsToolBarVisible() + && ( aKeyEvent.iScanCode == EStdKeyDevice3 + || aKeyEvent.iScanCode == EStdKeyEnter + || aKeyEvent.iScanCode == EStdKeyNkpEnter ) ) + { + if ( iController.UiConfigManagerPtr() ) + { + if ( iController.UiConfigManagerPtr()->IsOpticalJoyStickSupported() ) + { + MSKCapture = ETrue; + } + else + { + if ( iController.UiConfigManagerPtr()->IsXenonFlashSupported() ) + { + if ( iController.CheckFlash() + && static_cast( &iView ) + ->StartMskCaptureL() ) + { + return EKeyWasConsumed; + } + } + else if ( static_cast( &iView )->StartMskCaptureL() ) + { + return EKeyWasConsumed; + } + } + } + } + + TBool selfTimerEnabled = appui->SelfTimerEnabled(); + TBool timeLapseEnabled = appui->CurrentBurstMode() == ECamImageCaptureTimeLapse; + + // if currently capturing a sequence + if ( iController.SequenceCaptureInProgress() ) + { + // if capturing an advanced timelapse under the press to start, press to stop rules + // (i.e. not selftimer which captures 6 images) + if ( timeLapseEnabled && !selfTimerEnabled ) + { + // Stop the capture now + iController.StopSequenceCaptureL(); + // Update CBA for setup pane usage + TRAP_IGNORE( static_cast( &iView )->UpdateCbaL() ); + PRINT( _L("Camera <= CCamStillPreCaptureContainer: sequence capture stopped")) + return EKeyWasConsumed; + } + else + { + // For certain products normal sequence capture, if we + // are already capturing a burst, just consume but ignore it. + PRINT( _L("Camera <= CCamStillPreCaptureContainer: ignored during sequence")) + return EKeyWasConsumed; + } + } + + if ( iController.UiConfigManagerPtr() && + iController.UiConfigManagerPtr()->IsAutoFocusSupported() ) + { + // If the shutter key has continued to a full press OR + // we are already focussed (as scene is a forced focus mode) + if ( iKeyShutter + || !iPhotoSceneUsesReticule + ) + { + iKeyShutter = EFalse; + + // Check if we are in Burst Mode with the controller not currently focussed. + if ( appui->IsBurstEnabled() + && iController.CurrentOperation() != ECamFocused && + iController.CurrentOperation() != ECamFocusFailed ) + { + // We want to start focus if in multishot and NOT in self-timer mode + // and current scene allows autofocus (ie if it's not forced) + if ( !selfTimerEnabled + && iPhotoSceneUsesReticule + ) + { + if( iXenonFlashSupported && timeLapseEnabled && !iController.CheckFlash() ) + { + // In time lapse mode, do not start focusing with full press if + // Xenon flash is not ready. This is not the case for normal + // burst mode, because flash is not used there. + iKeyShutter = ETrue; + PRINT( _L("Camera <= CCamStillPreCaptureContainer: Flash not ready in timelapse mode, ignore key")) + return EKeyWasConsumed; + } + // Below code commented out - fast capture should be supported also + // in burst/sequence capture mode. Also, in case focusing is already + // in progress, the call won't do anything. + // iController.StartAutoFocus(); + } + } + } +#ifndef __WINS__ + else + { + // This means we've received a full press without a half press - + // probably because the half press was consumed by the post capture view + // and triggered a switch to this view. In this case, we don't want to + // take a picture, therefore ignore the event. + if ( !appui->IsSecondCameraEnabled() + && !MSKCapture ) + { + PRINT( _L("Camera <= CCamStillPreCaptureContainer: full press without half press ignored")) + return EKeyWasConsumed; + } + } +#endif // __WINS__ + } + else + { + // in case AF is not supported, check memory here before capturing + if ( !iController.IsViewFinding() || !appui->CheckMemoryL() ) + { + return EKeyWasConsumed; + } + } + + if( iXenonFlashSupported + && !appui->IsSecondCameraEnabled() + && !MSKCapture + && !iController.CheckFlash() ) + { + if( !appui->IsBurstEnabled() || (timeLapseEnabled && selfTimerEnabled) ) + { + // For non-burst case, or time lapse captures with self timer, + // we do not allow primary camera capture if flash is required, + // but not ready. + iKeyShutter = ETrue; + PRINT( _L("Camera <= CCamStillPreCaptureContainer: Flash not ready, ignore key")) + return EKeyWasNotConsumed; + } + } + if ( iController.UiConfigManagerPtr() + && !iController.UiConfigManagerPtr()->IsAutoFocusSupported() + && iController.IsTouchScreenSupported() ) + { + CAknToolbar* fixedToolbar = appui->CurrentFixedToolbar(); + if ( fixedToolbar ) + { + CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension(); + if ( extension ) + { + extension->SetShown( EFalse ); + } + } + } + + // Go straight to capture + keyResponse = appui->StartCaptureL( aKeyEvent ); + + // Blank out the softkeys if we are capturing + if ( EKeyWasConsumed == keyResponse + && !iController.SequenceCaptureInProgress() + && !iController.CaptureModeTransitionInProgress() + ) + { + // Only blank the cba if self timer is not enabled + // or it is enabled but not counting down + if ( !selfTimerEnabled + || ( selfTimerEnabled && !appui->SelfTimer()->IsActive() ) + ) + { + static_cast( &iView )->BlankSoftkeysL(); + } + if ( iController.IsTouchScreenSupported() ) + { + CAknToolbar* fixedToolbar = appui->CurrentFixedToolbar(); + if ( fixedToolbar ) + { + fixedToolbar->SetToolbarVisibility( EFalse ); + } + } + } + + if ( iController.IsTouchScreenSupported() ) + { + // Hide the toolbar in case full press in burstmode + if ( appui->IsBurstEnabled() ) + { + CAknToolbar* fixedToolbar = appui->CurrentFixedToolbar(); + if ( fixedToolbar ) + { + fixedToolbar->SetToolbarVisibility( EFalse ); + } + } + } + + PRINT( _L("Camera <= CCamStillPreCaptureContainer::HandleCaptureKeyEventL")) + return keyResponse; + } + + +// ---------------------------------------------------- +// CCamStillPreCaptureContainer::HandleShutterKeyEventL +// Change the current capture state following shutter +// key events +// ---------------------------------------------------- +// +TKeyResponse +CCamStillPreCaptureContainer::HandleShutterKeyEventL( const TKeyEvent& aKeyEvent, + TEventCode aType ) + { + CCamAppUi* appui = static_cast( iEikonEnv->AppUi() ); + __ASSERT_DEBUG(appui, CamPanic(ECamPanicNullPointer)); + TBool MSKCapture(EFalse); + if ( !appui->IsToolBarVisible() + && aKeyEvent.iScanCode == EStdKeyDevice3 + && iController.UiConfigManagerPtr() + && iController.UiConfigManagerPtr()->IsOpticalJoyStickSupported() ) + { + MSKCapture = ETrue; + } + + // If the key is a half-press and down +#ifndef __WINS__ + if ( aKeyEvent.iScanCode == iPrimaryCameraAFKeys[0] +#else + if ( aKeyEvent.iScanCode == EProductKeyCaptureHalf && + !( aKeyEvent.iModifiers & EModifierShift ) +#endif //__WINS__ + && iController.UiConfigManagerPtr() + && iController.UiConfigManagerPtr()->IsAutoFocusSupported() ) + { + if ( aType == EEventKeyDown ) + { + OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTURECONTAINER_HANDLESHUTTERKEYEVENTL, "e_CAM_PRI_AF_LOCK 1" ); + PRINT( _L("Camera => CCamStillPreCaptureContainer::HandleHalfKeyEventL DOWN")) + PERF_MESSAGE_L2( EPerfMessageCaptureKeyHalfPressed ); + // If the shutter key has been half pressed + iKeyShutter = ETrue; // Shutter key - first stage press -> start focussing... + + // check for active viewfinder and available space before proceeding with capture + if ( !iController.IsViewFinding() || !appui->CheckMemoryL() ) + { + // no memory available - stop capture + return EKeyWasConsumed; + } + + if ( iController.UiConfigManagerPtr() + && iController.UiConfigManagerPtr()->IsAutoFocusSupported() + && !appui->SelfTimerEnabled() + && iPhotoSceneUsesReticule ) + { + OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTURECONTAINER_HANDLESHUTTERKEYEVENTL, "e_CAM_APP_AF 1" ); //CCORAPP_AF_START + iController.StartAutoFocus(); + } + + CAknToolbar* fixedToolbar = appui->CurrentFixedToolbar(); + + if ( fixedToolbar ) + { + CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension(); + if ( extension ) + { + extension->SetShown( EFalse ); + } + } + iZoomPane->MakeVisible( EFalse, ETrue ); + + return EKeyWasConsumed; + } + else if ( aType == EEventKeyUp && !MSKCapture ) + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::HandleKeyEventL EProductKeyCaptureHalf up ")) + // If full shutter press is released + // The order of conditions is important here as half shutter only release resets the + // value of iKeyShutter + if ( !iKeyShutter ) + { + // Cancelling of a press-and-hold burst is handled + // when the full-press is released, so nothing to + // do when release the half-press apart from consume it + PRINT( _L("Camera <= CCamStillPreCaptureContainer::HandleKeyEventL no action, return EKeyWasConsumed")) + return EKeyWasConsumed; + } + else + { + // if half shutter only is released + iKeyShutter = EFalse; + TCamCaptureOperation operation = iController.CurrentOperation(); + // if not in self timer mode or about to start a capture + if ( !appui->SelfTimerEnabled() + && !iController.CapturePending() + || ECamFocusing == operation + ) + { + // In timelapse mode, when stopping with capture key, + // need this condition to avoid unnecessary entering + // to no-operation while already completing. + if( ECamCompleting != operation ) + { + iController.CancelFocusAndCapture(); + } + + // if not currently capturing + if ( ECamCapturing != operation ) + { + appui->UpdateCba(); + } + } + return EKeyWasConsumed; + } + } + else + { + // Removal of warning + } + } + return EKeyWasNotConsumed; + } + + + +// --------------------------------------------------------------------------- +// DrawAdditionalIcons +// +// --------------------------------------------------------------------------- +// +void +CCamStillPreCaptureContainer::DrawAdditionalIcons( CBitmapContext& aGc ) const + { + if( iXenonFlashSupported && iFlashIconVisible && ECamActiveCameraSecondary != iController.ActiveCamera() ) + { + DrawFlashIcon( aGc ); + } + } + +// ---------------------------------------------------- +// CCamStillPreCaptureContainer::ResolutionIndicatorIconPsiKey +// Returns the PSI key relating to the array of resolution +// indicator bitmaps. +// ---------------------------------------------------- +// +TCamPsiKey CCamStillPreCaptureContainer::ResolutionIndicatorIconPsiKey() const + { + return ECamPsiPrecapStillQualityIconIds; + } + +// --------------------------------------------------------------------------- +// virtual GetAPResourceId +// (From CCamPreCaptureContainerBase) +// +// Helper method to select the AP resource used to set AP items. +// --------------------------------------------------------------------------- +// +TInt CCamStillPreCaptureContainer::GetAPResourceId() const + { + CCamAppUi* appUi = static_cast( iEikonEnv->AppUi() ); + TBool embedded = appUi->IsEmbedded(); + TInt resId = 0; + if( embedded ) + { + if ( !appUi->IsSecondCameraEnabled() ) + { + resId = R_CAM_EMB_STILL_PRE_CAPTURE_AP_ITEMS_ADVANCED; + } + } + else + { + if ( !appUi->IsSecondCameraEnabled() ) + { + resId = R_CAM_STILL_PRE_CAPTURE_AP_ITEMS_ADVANCED; + } + else + { + resId = R_CAM_STILL_PRE_CAPTURE_AP_ITEMS_SECONDARY; + } + } + return resId; + } + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::SizeChanged +// Called by framework when the component size is changed +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::SizeChanged() + { + CCamPreCaptureContainerBase::SizeChanged(); + if ( iXenonFlashSupported ) + { + LayoutFlashIcon(); + } + } + + +// --------------------------------------------------------------------------- +// HandleForegroundEventL +// --------------------------------------------------------------------------- +// +void +CCamStillPreCaptureContainer::HandleForegroundEventL( TBool aForeground ) + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::HandleForegroundEventL") ) + + CCamPreCaptureContainerBase::HandleForegroundEventL( aForeground ); + if ( iXenonFlashSupported ) + { + + // Subscribe / unsubscribe from flash related events + // When going to background -> unsubscribe + // Otherwise -> subscribe + SubscribeFlashEvents( aForeground ); + } + + PRINT( _L("Camera => CCamStillPreCaptureContainer::HandleForegroundEventL") ) + } + + + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::FlashIconVisible +// Called when Xenon flash icon visibility changes +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::FlashIconVisible( TBool aVisible ) + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::FlashIconVisible") ) + if( ECamActiveCameraSecondary == iController.ActiveCamera() ) + { + // Do not draw the flash icon even if visible, if using secondary + // camera, as it does not use the flash at all. + return; + } + + + if( ECamCapturing == iController.CurrentOperation() || + ECamCompleting == iController.CurrentOperation() ) + { + if ( !iFlashIconVisible && aVisible ) + { + // During capture, if flash icon is currently invisible, + // do not make it visible. Also if the state has not changed, + // we don't need to redraw anything + return; + } + } + + if( iFlashIconVisible != aVisible ) + { + // Icon state has changed. Redraw. + + iFlashIconVisible = aVisible; + + // State changed, need to redraw + ActivateGc(); + + // Invalidate the flash icon area + RWindow window = Window(); + window.Invalidate( iFlashIconRect ); + window.BeginRedraw( iFlashIconRect ); + + // Redraw the background in that area + Redraw( iFlashIconRect ); + + // Draw the flash icon itself + CWindowGc& gc = SystemGc(); + if( aVisible ) + { + DrawFlashIcon( gc ); + } + + // Tell the window redraw is finished and deactivate Gc + window.EndRedraw(); + DeactivateGc(); + } + PRINT( _L("Camera <= CCamStillPreCaptureContainer::FlashIconVisible") ) + } + + + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::FlashError +// Called when there was an error while recharging +// the Xenon flash. +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::FlashError() + { + } + + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::InitFlashIconL +// +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::InitFlashIconL() + { + iFlashIconVisible = EFalse; + + // Init flash icon bitmap and mask + TFileName resFileName; + CamUtility::ResourceFileName( resFileName ); + TPtrC resname = resFileName; + + AknIconUtils::CreateIconL( iFlashBitmap, + iFlashBitmapMask, + resname, + EMbmCameraappQgn_indi_cam4_flash_on, + EMbmCameraappQgn_indi_cam4_flash_on_mask ); + + // Subscribe to blink events + if( CCamFlashStatus* flashStatus = iController.FlashStatus() ) + { + flashStatus->Subscribe( this ); + iFlashIconVisible = flashStatus->FlashIconVisible(); + PRINT( _L("Camera :: CCamStillPreCaptureContainer::InitFlashIconL - Flash events subscribed") ) + } + else + { + iFlashIconVisible = EFalse; + } + } + + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::LayoutFlashIcon +// +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::LayoutFlashIcon() + { + // Set rectangle + TRect rect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, rect ); + TInt cba = AknLayoutUtils::CbaLocation() == + AknLayoutUtils::EAknCbaLocationLeft; + TAknLayoutRect parent; + parent.LayoutRect( rect, AknLayoutScalable_Apps::cam6_mode_pane( cba ) ); + TAknLayoutRect l; + l.LayoutRect( parent.Rect(), + AknLayoutScalable_Apps::main_camera4_pane_g3( 1 ) ); + iFlashIconRect = l.Rect(); + if( iFlashBitmap ) + { + AknIconUtils::SetSize( iFlashBitmap, iFlashIconRect.Size() ); + } + } + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::DrawFlashIcon +// +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::DrawFlashIcon( CBitmapContext& aGc ) const + { + if( iFlashBitmap ) + { + // aGc.DrawBitmap( iFlashIconRect, iFlashBitmap ); + aGc.BitBltMasked( iFlashIconRect.iTl, iFlashBitmap, iFlashIconRect.Size(), iFlashBitmapMask, ETrue ); + } + } + +// --------------------------------------------------------------------------- +// SubscribeFlashEvents +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::SubscribeFlashEvents( TBool aSubscribe ) + { + if( CCamFlashStatus* flashStatus = iController.FlashStatus() ) + { + if( aSubscribe ) + { + // Re-subscribe when going to foreground + // Duplicate subscription is acceptable since only one observer can subscribe to + // flash related events. + flashStatus->Subscribe( this ); + iFlashIconVisible = flashStatus->FlashIconVisible(); + PRINT( _L("Camera :: CCamStillPreCaptureContainer::SubscribeFlashEvents - Flash events subscribed") ) + } + else + { + // Un-subscribe when going to background + flashStatus->Subscribe( NULL ); + iFlashIconVisible = EFalse; + PRINT( _L("Camera :: CCamStillPreCaptureContainer::SubscribeFlashEvents - Flash events unsubscribed") ) + } + } + } + +// --------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::MakeVisible +// +// Used to subscribe / unsubscribe from flash events when the control is +// activated / deactivated (standby mode is enabled) +// --------------------------------------------------------------------------- +// +void CCamStillPreCaptureContainer::MakeVisible( TBool aVisible ) + { + PRINT1( _L("Camera => CCamPreCaptureContainerBase::MakeVisible %d"), aVisible ) + if ( iXenonFlashSupported ) + { + // Subscribe / unsubscribe from flash related events + // When going to background -> unsubscribe + // Otherwise -> subscribe + SubscribeFlashEvents( aVisible ); + + } + CCamPreCaptureContainerBase::MakeVisible( aVisible ); + PRINT( _L("Camera <= CCamPreCaptureContainerBase::MakeVisible") ) + } + + +// ----------------------------------------------------------------------------- +// CCamStillPreCaptureContainer::InitVfGridL +// ----------------------------------------------------------------------------- +// +void +CCamStillPreCaptureContainer::InitVfGridL( const TRect& /*aRect*/ ) + { + PRINT( _L("Camera => CCamStillPreCaptureContainer::InitVfGridL") ); + iVfGridRect = ViewFinderFrameRect(ECamControllerImage); + + // No vf grid in secondary camera. + if( ECamActiveCameraSecondary != iController.ActiveCamera() ) + { + // Create grid drawer if not done yet + if( !iVfGridDrawer ) + { + iVfGridDrawer = CCamVfGridFactory::CreateVfGridDrawerL( KGridDrawerUid ); + } + ResetVFGridVisibility(); + + PRINT( _L("Camera <> CCamStillPreCaptureContainer: Setting vf grid lines..") ); + + // Setting the lines for grid is specific operation + // for CCamLineVfGridDrawer class not defined in MCamVfGridDrawer interface. + CCamLineVfGridDrawer* ptr = static_cast( iVfGridDrawer ); + ptr->SetLinesL ( iVfGridRect, KGridHrzLines, KGridVrtLines, EFalse ); + ptr->SetPenStyle( KGridStyle ); + ptr->SetPenSize ( TSize( KGridThickness, KGridThickness ) ); + ptr->SetPenColor( KGridColor ); + } + else + { + PRINT( _L("Camera <> CCamStillPreCaptureContainer: Secondary cam active, no vf grid") ); + } + PRINT( _L("Camera <= CCamStillPreCaptureContainer::InitVfGridL") ); + } +// End of File