/*
* 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 video image pre-capture view*
*/
// INCLUDE FILES
#include "CamAppUiBase.h"
#include "CamVideoPreCaptureContainer.h"
#include "CamLogger.h"
#include "CamPanic.h"
#include "CamUtility.h"
#include "CamAppUi.h"
#include "CamSidePane.h"
#include "CamNaviProgressBarControl.h"
#include "CamViewBase.h"
#include "CamIndicator.h"
#include "CamIndicatorData.h"
#include "CamIndicatorResourceReader.h"
#include "CameraUiConfigManager.h"
#include "camactivepalettehandler.h"
#include <eikenv.h>
#include <cameraapp.mbg>
#include <eikappui.h> // For CCoeAppUiBase
#include <eikapp.h> // For CEikApplication
#include <AknIconUtils.h>
#include <akntoolbar.h>
#include <akntoolbarextension.h>
#include <barsread.h>
#include <cameraapp.rsg>
#include <vgacamsettings.rsg>
#include <aknlayoutscalable_apps.cdl.h>
#include <layoutmetadata.cdl.h>
#include <touchfeedback.h>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "CamVideoPreCaptureContainerTraces.h"
#endif
// ================= MEMBER FUNCTIONS =======================
// ---------------------------------------------------------------------------
// CCamVideoPreCaptureContainer::NewL
// Symbian OS two-phased constructor
// ---------------------------------------------------------------------------
//
CCamVideoPreCaptureContainer* CCamVideoPreCaptureContainer::NewL(
CCamAppController& aController,
CAknView& aView,
const TRect& aRect )
{
CCamVideoPreCaptureContainer* self = new( ELeave ) CCamVideoPreCaptureContainer(
aController, aView );
CleanupStack::PushL( self );
self->ConstructL( aRect );
CleanupStack::Pop( self );
// Return newly created CCamVideoPreCaptureContainer instance
return self;
}
// Destructor
CCamVideoPreCaptureContainer::~CCamVideoPreCaptureContainer()
{
PRINT( _L("Camera => ~CCamVideoPreCaptureContainer") );
if ( iFeedback )
{
iFeedback->RemoveFeedbackForControl( this );
}
delete iFileTypeIndicator;
PRINT( _L("Camera <= ~CCamVideoPreCaptureContainer") );
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::ConstructL
// Symbian OS 2nd phase constructor
// ---------------------------------------------------------
//
void CCamVideoPreCaptureContainer::ConstructL( const TRect& aRect )
{
PRINT( _L("Camera => CCamVideoPreCaptureContainer::ConstructL"))
TCamVideoResolution res = iController.GetCurrentVideoResolution();
iVFRes = iController.VideoViewFinderResourceId( res );
BaseConstructL( aRect );
iShowReticule = EFalse;
iSidePane->SetCaptureMode( ECamControllerVideo );
CreateFiletypeIndicatorL();
iRecordState = ECamNotRecording;
// Get the co-ordinates where the resolution
// icon should move to during video capture
TAknLayoutRect layoutRect;
TRect rect;
TAknLayoutRect vidProgressPane;
if ( Layout_Meta_Data::IsLandscapeOrientation() )
{
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, rect );
}
else
{
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );
}
if ( CamUtility::IsNhdDevice() )
{
TInt variant = Layout_Meta_Data::IsLandscapeOrientation();
vidProgressPane.LayoutRect( rect,
AknLayoutScalable_Apps::vid4_progress_pane( variant ) );
layoutRect.LayoutRect( vidProgressPane.Rect(),
AknLayoutScalable_Apps::vid4_progress_pane_g1() );
}
else
{
TInt cba = AknLayoutUtils::CbaLocation() ==
AknLayoutUtils::EAknCbaLocationLeft;
vidProgressPane.LayoutRect( rect,
AknLayoutScalable_Apps::vid6_indi_pane( cba ) );
layoutRect.LayoutRect( vidProgressPane.Rect(),
AknLayoutScalable_Apps::vid6_indi_pane_g1( !cba ) );// quality
}
iResolutionIndicatorVidcapPosition = layoutRect.Rect();
if ( !iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )
{
static_cast<CCamPreCaptureContainerBase*>( this )
->SetupActivePaletteL( static_cast<CCamViewBase*>(&iView) );
}
if ( iController.IsTouchScreenSupported() )
{
// Get pointer of touch feedback instance
iFeedback = MTouchFeedback::Instance();
if ( !iFeedback )
iFeedback = MTouchFeedback::CreateInstanceL();
}
}
// ---------------------------------------------------------------------------
// CCamVideoPreCaptureContainer::CCamVideoPreCaptureContainer
// C++ constructor
// ---------------------------------------------------------------------------
//
CCamVideoPreCaptureContainer::CCamVideoPreCaptureContainer(
CCamAppController& aController,
CAknView& aView )
: CCamPreCaptureContainerBase( aController, aView )
{
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::HandleControllerEventL
// Receives notifications about changes in recording state from the controller
// ---------------------------------------------------------
//
void
CCamVideoPreCaptureContainer
::HandleControllerEventL( TCamControllerEvent aEvent, TInt aError )
{
PRINT1( _L("Camera => CCamVideoPreCaptureContainer::HandleControllerEventL aEvent:%d"), aEvent )
switch( aEvent )
{
// ---------------------------------------------------
case ECamEventOperationStateChanged:
{
TCamCaptureOperation operation = iController.CurrentOperation();
switch( operation )
{
case ECamCapturing:
{
if ( iController.IsTouchScreenSupported() && iFeedback )
{
iFeedback->SetFeedbackEnabledForThisApp( EFalse );
}
iRecordState = ECamRecording;
iResolutionIndicators[iCurrentIndicator]->SetRect(iResolutionIndicatorVidcapPosition);
break;
}
case ECamPaused:
{
iRecordState = ECamRecordPaused;
break;
}
default:
{
iRecordState = ECamNotRecording;
break;
}
}
break;
}
// ---------------------------------------------------
case ECamEventLocationSettingChanged:
{
// If the location setting was changed on, then the indicator should be visible
SetLocationIndicatorVisibility();
}
// ---------------------------------------------------
case ECamEventCameraChanged:
{
SetFileTypeIndicator();
break;
}
// ---------------------------------------------------
case ECamEventVideoFileTypeChanged:
{
SetResolutionIndicator();
SetFileTypeIndicator();
break;
}
// ---------------------------------------------------
case ECamEventVideoQualityChanged:
{
// To get correct viewfinder resolution:
// TCamVideoResolution res = iController.GetCurrentVideoResolution();
// iVFRes = iController.VideoViewFinderResourceId( res );
SetResolutionIndicator();
}
// ---------------------------------------------------
case ECamEventRecordComplete:
{
iResolutionIndicators[iCurrentIndicator]->SetRect( ResolutionIndicatorRect() );
iFileTypeIndicator->SetRect( iFileTypeIndicatorPosition );
if ( iController.IsTouchScreenSupported() && iFeedback )
{
iFeedback->SetFeedbackEnabledForThisApp( ETrue, ETrue );
}
break;
}
// ---------------------------------------------------
case ECamEventInitReady:
{
// event only sent if UIOrientationOverride feature is supported
if ( !iController.IsTouchScreenSupported() &&
iController.CurrentMode()== ECamControllerVideo )
{
CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
if ( appUi )
{
if ( !appUi->ActivePalette() )
{
OstTrace0( CAMERAAPP_PERFORMANCE, CCAMVIDEOPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_SETUP 1" );
static_cast<CCamPreCaptureContainerBase*>( this )
->SetupActivePaletteL( static_cast<CCamViewBase*>(&iView) );
OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMVIDEOPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_SETUP 0" );
}
else
{
OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMVIDEOPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_UPDATE 1" );
appUi->APHandler()->UpdateActivePaletteL();
OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMVIDEOPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_UPDATE 0" );
}
appUi->SetActivePaletteVisibility( ETrue );
}
}
break;
}
// ---------------------------------------------------
default:
{
// otherwise, do nothing
}
// ---------------------------------------------------
}
CCamPreCaptureContainerBase::HandleControllerEventL( aEvent, aError );
PRINT( _L("Camera <= CCamVideoPreCaptureContainer::HandleControllerEventL"))
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::HandleForegroundEventL
// Handle events sending app to foreground and background
// ---------------------------------------------------------
void CCamVideoPreCaptureContainer::HandleForegroundEventL( TBool aForeground )
{
CCamPreCaptureContainerBase::HandleForegroundEventL( aForeground );
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::ViewFinderLayoutResourceIds
// Return the layout resource id for the viewfinder
// (Note: reticule not required for video viewfinder)
// ---------------------------------------------------------
//
void CCamVideoPreCaptureContainer::ViewFinderLayoutResourceIds(
TInt& aViewFinderLayoutId,
TInt& /*aReticuleLayoutId*/ ) const
{
aViewFinderLayoutId = iVFRes;
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::SetResolutionIndicator
// Sets the resolution indictator to the required icon
// ---------------------------------------------------------
//
void CCamVideoPreCaptureContainer::SetResolutionIndicator()
{
iCurrentIndicator = iController.IntegerSettingValue( ECamSettingItemVideoQuality );
}
// ---------------------------------------------------------
// CCamStillPreCaptureContainer::SetLocationIndicatorVisibility
// Sets the resolution indicator visibility, if it is set or not.
// Do nothing if video taken.
// ---------------------------------------------------------
//
void CCamVideoPreCaptureContainer::SetLocationIndicatorVisibility()
{
// The setting stored is an index of whether the location setting is on or off
iLocationIndicatorVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation ));
}
// ----------------------------------------------------
// CCamStillPreCaptureContainer::LocationtionIndicatorRect
// Returns the rectangle defining the position and size
// of the location icon
// ----------------------------------------------------
//
TRect CCamVideoPreCaptureContainer::LocationIndicatorRect()
{
TAknLayoutRect layoutRect;
//layoutRect.LayoutRect( Rect(), ROID(R_CAM_VIDEO_PRECAP_LOCATION_ID) );
return layoutRect.Rect();
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::IncreaseFlashSettingL
// Move up through the flash settings
// ----------------------------------------------------
//
void CCamVideoPreCaptureContainer::IncreaseFlashSettingL()
{
if ( iController.UiConfigManagerPtr()->IsVideoLightSupported() )
{
CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() );
if ( !iZoomPane->IsVisible()
&& !appUi->IsSecondCameraEnabled()
)
{
TCamFlashId flash =
static_cast< TCamFlashId >
( iController.IntegerSettingValue( ECamSettingItemDynamicVideoFlash ) );
if ( flash == ECamFlashForced )
{
flash = ECamFlashOff;
}
else
{
flash = ECamFlashForced;
}
iController.SetIntegerSettingValueL(ECamSettingItemDynamicVideoFlash, flash);
}
} // video light supported check
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::DecreaseFlashSettingL
// Move down through the flash settings
// ----------------------------------------------------
//
void CCamVideoPreCaptureContainer::DecreaseFlashSettingL()
{
//Given we have two flash modes in video, Increase and Decrease are functionally equivalent
IncreaseFlashSettingL();
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::HandleCaptureKeyEventL
// Change the current capture state
// ----------------------------------------------------
//
TKeyResponse
CCamVideoPreCaptureContainer::HandleCaptureKeyEventL( const TKeyEvent& aKeyEvent )
{
PRINT( _L("Camera => CCamVideoPreCaptureContainer::HandleCaptureKeyEventL") );
TKeyResponse keyResponse = EKeyWasNotConsumed;
// check our current operation state
TCamCaptureOperation operation = iController.CurrentOperation();
if ( (ECamCapturing == operation ) ||
(ECamPaused == operation ) )
{
// iController.StopVideoRecording();
// Stop the video recording using ECamCmdStop command,
// similarily to what happens when Stop softkey is pressed.
iView.HandleCommandL( ECamCmdStop );
}
else if ( iController.VideoRecordPending() )
{
PRINT( _L("Camera <> Video capture already pending") );
// Do nothing if already pending
keyResponse = EKeyWasConsumed;
}
else
{
CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
if ( iController.UiConfigManagerPtr()
&& !iController.UiConfigManagerPtr()->IsAutoFocusSupported()
&& iController.IsTouchScreenSupported() )
{
CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();
if ( fixedToolbar )
{
CAknToolbarExtension* extension = fixedToolbar->ToolbarExtension();
if ( extension )
{
extension->SetShown( EFalse );
}
}
}
// neither recording nor paused
// so attempt to start recording
PRINT( _L("Camera <> starting capture") );
keyResponse = appUi->StartCaptureL( aKeyEvent );
// Hide the toolbar if we are capturing
if( EKeyWasConsumed == keyResponse )
{
// Repeated key events (MSK) are ignored.
iController.SetDemandKeyRelease( ETrue );
// fixed toolbar is used only with touch devices
if ( iController.IsTouchScreenSupported() )
{
CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();
if ( fixedToolbar )
{
fixedToolbar->SetToolbarVisibility( EFalse );
}
}
}
}
PRINT( _L("Camera <= CCamVideoPreCaptureContainer::HandleCaptureKeyEventL") );
return keyResponse;
}
// ----------------------------------------------------
// virtual InitVfGridL
// ----------------------------------------------------
void
CCamVideoPreCaptureContainer::InitVfGridL( const TRect& /*aRect*/ )
{
PRINT(_L("CCamVideoPreCaptureContainer::InitVfGridL -->"));
// Skip constructing vf grid drawer.
// As effect the vf grid is never drawn.
PRINT(_L("CCamVideoPreCaptureContainer::InitVfGridL <--"));
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::BlankSoftKeysL
// Blank the softkeys
// ----------------------------------------------------
//
void CCamVideoPreCaptureContainer::BlankSoftkeysL()
{
static_cast<CCamViewBase&>(iView).SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::HandleShutterKeyEventL
// Change the current capture state following shutter
// key events
// ----------------------------------------------------
//
TKeyResponse CCamVideoPreCaptureContainer::HandleShutterKeyEventL( const TKeyEvent& /*aKeyEvent*/,
TEventCode aType )
{
CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
if ( appUi &&
appUi->CurrentViewState() == ECamViewStatePreCapture &&
aType == EEventKeyDown &&
iController.IsTouchScreenSupported() )
{
CAknToolbar* toolbar = appUi->CurrentFixedToolbar();
if ( toolbar )
{
CAknToolbarExtension* toolbarExtension =
toolbar->ToolbarExtension();
if ( toolbarExtension && toolbarExtension->IsShown() )
{
toolbarExtension->SetShown( EFalse );
return EKeyWasConsumed;
}
}
}
return EKeyWasNotConsumed;
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::DrawAdditionalIcons
// Draw the video file type indicator
// ---------------------------------------------------------
//
void CCamVideoPreCaptureContainer::DrawAdditionalIcons(CBitmapContext& aGc) const
{
CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
TCamCaptureOperation videoOperation = iController.CurrentVideoOperation();
// It is essential to check, that the current view state is right.
// Draw request could still arrive to precapture view,
// when in fact video is stopped and transition to post capture
// is in progress. During that time, additional icons should
// not be drawn.
if( appUi
&& appUi->CurrentViewState() == ECamViewStatePreCapture
&& appUi->DrawPreCaptureCourtesyUI()
&& !appUi->IsSecondCameraEnabled()
&& ( CamUtility::IsNhdDevice() || videoOperation == ECamNoOperation )
)
{
iFileTypeIndicator->Draw( aGc );
}
}
// ---------------------------------------------------------
// CCamVideoPreCaptureContainer::CreateFiletypeIndicatorL
// Create the video file type indicator
// ---------------------------------------------------------
//
void CCamVideoPreCaptureContainer::CreateFiletypeIndicatorL()
{
// Create reader
TResourceReader reader;
iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_VIDEO_FILETYPE_PANE_ID));
CCamIndicatorResourceReader* resourceReader =
CCamIndicatorResourceReader::NewLC( reader );
// Get indicator data from reader (there will be just 1)
CCamIndicatorData& indData = *( resourceReader->IndicatorData().At( 0 ) );
iFileTypeIndicator = CCamIndicator::NewL( indData.IndicatorRect() );
TInt numbitmaps = indData.IndicatorBitmapCount(); // no of bitmaps for indicator
TInt j;
for ( j = 0; j < numbitmaps; j++ )
{
// Side pane assumes that mask bitmap is defined after the
// normal one in the resource file
iFileTypeIndicator->AddIconL(
indData.IndicatorBitmapId( j ), // bitmap
indData.IndicatorBitmapId( j + 1 )); // mask
j++;
}
CleanupStack::PopAndDestroy( resourceReader );
CleanupStack::PopAndDestroy(); // reader
TAknLayoutRect layoutRect;
TRect rect;
TAknLayoutRect vidProgressPane;
TAknLayoutRect fileTypeIconLayout;
if ( Layout_Meta_Data::IsLandscapeOrientation() )
{
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, rect );
}
else
{
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );
}
if ( CamUtility::IsNhdDevice() )
{
TInt variant = Layout_Meta_Data::IsLandscapeOrientation();
vidProgressPane.LayoutRect( rect,
AknLayoutScalable_Apps::vid4_progress_pane( variant ) );
layoutRect.LayoutRect( vidProgressPane.Rect(),
AknLayoutScalable_Apps::vid4_progress_pane_g2() );
}
else
{
TInt cba = AknLayoutUtils::CbaLocation() ==
AknLayoutUtils::EAknCbaLocationLeft;
vidProgressPane.LayoutRect( rect,
AknLayoutScalable_Apps::vid6_indi_pane( cba ) );
layoutRect.LayoutRect( vidProgressPane.Rect(),
AknLayoutScalable_Apps::vid6_indi_pane_g2( cba ) );// type
fileTypeIconLayout = layoutRect;
}
iFileTypeIndicator->SetRect( layoutRect.Rect() );
iFileTypeIndicatorPosition = layoutRect.Rect();
// Initialise the indicator
SetFileTypeIndicator();
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::SetFileTypeIndicator
// Sets the video file type indicator depending on the current
// video file type setting.
// ----------------------------------------------------
//
void CCamVideoPreCaptureContainer::SetFileTypeIndicator()
{
if ( iFileTypeIndicator )
{
// If the current mode is video then show the relevant icon
// for the current video file type.
TCamVideoFileType fileType = static_cast< TCamVideoFileType >
( iController.IntegerSettingValue( ECamSettingItemVideoFileType ) );
if ( fileType == ECamVideoMpeg4 )
{
iFileTypeIndicator->SetIcon( 0 );
}
// Otherwise display the H263 icon.
else
{
iFileTypeIndicator->SetIcon( 2 );
}
}
}
// ----------------------------------------------------
// CCamVideoPreCaptureContainer::ResolutionIndicatorIconPsiKey
// Returns the PSI key relating to the array of resolution
// indicator bitmaps.
// ----------------------------------------------------
//
TCamPsiKey CCamVideoPreCaptureContainer::ResolutionIndicatorIconPsiKey() const
{
return ECamPsiPrecapVideoQualityIconIds;
}
// ---------------------------------------------------------------------------
// virtual GetAPResourceId
// (From CCamPreCaptureContainerBase)
//
// Helper method to select the AP resource used to set AP items.
// ---------------------------------------------------------------------------
//
TInt CCamVideoPreCaptureContainer::GetAPResourceId() const
{
CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
TBool embedded = appUi->IsEmbedded();
TInt resId = 0;
if( embedded )
{
if ( !appUi->IsSecondCameraEnabled() )
{
resId = R_CAM_EMB_VIDEO_PRE_CAPTURE_AP_ITEMS_ADVANCED;
}
}
else
{
if ( !appUi->IsSecondCameraEnabled() )
{
resId = R_CAM_VIDEO_PRE_CAPTURE_AP_ITEMS_ADVANCED;
}
else
{
resId = R_CAM_VIDEO_PRE_CAPTURE_AP_ITEMS_SECONDARY;
}
}
return resId;
}
// End of File