diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/camerauiconfigmanager/src/CameraUiConfigManagerImp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/camerauiconfigmanager/src/CameraUiConfigManagerImp.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,985 @@ +/* +* 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: Helper class which handles reading and storing the cr keys + * and its values. + * +*/ + + + +// Includes +#include +#include +#include +#include +#include +#include "CameraUiConfigManagerImp.h" +#include "CameraConfigurationCrKeys.h" +#include "camlogging.h" +#include "CamSettings.hrh" + + +// =========================================================================== +// Constants + +const TInt KCamCRStringInitialLength = 1024; +_LIT( KItemsSeparator, "," ); + + +// =========================================================================== + +inline TBool SettingIdMatches( const TInt* aSettingId, + const TSupportedSettingsData& aSettingItem ) + { + return ( *aSettingId == aSettingItem.iSettingId ); + }; + +// =========================================================================== + + +// Class methods + +// --------------------------------------------------------------------------- +// CCameraUiConfigManagerImp::NewL +// Symbian OS two-phased constructor +// --------------------------------------------------------------------------- +// +CCameraUiConfigManagerImp* CCameraUiConfigManagerImp::NewL() + { + CCameraUiConfigManagerImp* self = CCameraUiConfigManagerImp::NewLC(); + CleanupStack::Pop( self ); + return self; + } + + + +// --------------------------------------------------------------------------- +// CCameraUiConfigManagerImp::NewLC +// Symbian OS two-phased constructor +// --------------------------------------------------------------------------- +// +CCameraUiConfigManagerImp* CCameraUiConfigManagerImp::NewLC() + { + CCameraUiConfigManagerImp* self = new( ELeave ) CCameraUiConfigManagerImp(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +// --------------------------------------------------------------------------- +// CCameraUiConfigManagerImp::~CCameraUiConfigManagerImp +// Destructor +// --------------------------------------------------------------------------- +// +CCameraUiConfigManagerImp::~CCameraUiConfigManagerImp() + { + for( TInt index = 0;index < iSupportedSettings.Count();index++ ) + { + if ( iSupportedSettings[index] ) + { + iSupportedSettings[index]->iSupportedSettingItems.Close(); + } + } + iSupportedSettings.ResetAndDestroy(); + iSupportedSettings.Close(); + + delete iRepository; + } + + + + +// --------------------------------------------------------------------------- +// CCameraUiConfigManagerImp::ConstructL +// Symbian OS 2nd phase constructor +// --------------------------------------------------------------------------- +// +void CCameraUiConfigManagerImp::ConstructL() + { + iRepository = CRepository::NewL( KCameraDynamicConfigurationCrKeys ); + LoadAllDynamicSettingsL(); + } + + + +// ---------------------------------------------------------------------------------- +// CCameraUiConfigManagerImp::IsFeatureSupported +// ---------------------------------------------------------------------------------- +// +TInt CCameraUiConfigManagerImp::IsFeatureSupported( + const TCamDynamicSettings aSettingId ) const + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::IsFeatureSupportedL" )) + + TInt settingIndex ( KErrNotFound ); + TInt value(0); // setting not supported + + if ( iSupportedSettings.Count() > 0 ) + { + settingIndex = SearchInSettingsListFor( iSupportedSettings, + static_cast( aSettingId ) ); + } + else + { + // if there are no supported settings + } + + if ( KErrNotFound != settingIndex ) + { + if ( iSupportedSettings[settingIndex] ) + { + value = iSupportedSettings[settingIndex]->iSupportedValue; + } + } + else + { + // setting item not found; hence not supported. + } + PRINT1( _L("Camera <= CCameraUiConfigManagerImp::IsFeatureSupportedL = %d" ), value ); + return value; + } + + + +// +//CCameraUiConfigManagerImp::SupportedSettingItemsL +// +void CCameraUiConfigManagerImp::SupportedSettingItemsL( + const TCamDynamicSettings aSettingId, + RArray& aSupportedValues ) + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::SupportedSettingItemsL" )) + TInt settingIndex ( KErrNotFound ); + aSupportedValues.Reset(); + + if ( iSupportedSettings.Count() > 0 ) + { + settingIndex = SearchInSettingsListFor( iSupportedSettings, + static_cast( aSettingId ) ); + } + else + { + // do nothing + } + if ( KErrNotFound != settingIndex ) + { + // if the index is valid, copy all corresponding setting items to the array + for ( TInt i = 0; + i < iSupportedSettings[settingIndex]->iSupportedSettingItems.Count(); + i++ ) + { + if ( iSupportedSettings[settingIndex] ) + { + aSupportedValues.AppendL( + iSupportedSettings[settingIndex]->iSupportedSettingItems[i] ); + } + } + } + else + { + User::Leave( KErrNotSupported ); + } + + PRINT( _L("Camera <= CCameraUiConfigManagerImp::SupportedSettingItemsL" )) + } + + + +// --------------------------------------------------------------------------- +// CCameraUiConfigManager::LoadAllDynamicSettingsL +// Load all dynamic settings +// --------------------------------------------------------------------------- +// +void CCameraUiConfigManagerImp::LoadAllDynamicSettingsL() + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::LoadAllDynamicSettingsL()" )) + RArray settingItemDefaultData; + CleanupClosePushL( settingItemDefaultData ); + + TInt supportedValue = 0; + TInt error = KErrNone; + + for( TInt settingId = ( static_cast( ECamDynamicSettingsMin ) + 1 ); + settingId < static_cast( ECamDynamicSettingsMax ); + settingId++ ) + { + if ( LoadCrForFeatureSupport( settingId ) ) + { + error = iRepository->Get( MapSettingItemToCrFeatureKeyL( settingId ), + supportedValue ); + } + else + { + supportedValue = 1; + } + + if ( error ) break; // if any error reading CenRep; do proper clean-up + + switch( settingId ) + { + case ECamDynamicSettingCaptureToneDelaySupport: + case ECamDynamicSettingCaptureToneDelayValue: + case ECamDynamicSettingRequiredRamMemory: + case ECamDynamicSettingCriticalLevelRamMemory: + case ECamDynamicSettingRequiredRamMemoryFocusGained: + case ECamDynamicSettingCriticalLevelRamMemoryFocusGained: + case ECamDynamicSettingPhoto: + case ECamDynamicSettingPublishZoomState: + case ECamDynamicSettingAutofocusSetInHyperfocalAtStartup: + case ECamDynamicSettingLocation: + case ECamDynamicSettingKeyLockWatcher: + case ECamDynamicSettingSecondaryCamera: + case ECamDynamicSettingLensCover: + case ECamDynamicSettingXenonFlash: + case ECamDynamicSettingLightSensitivity: + case ECamDynamicSettingExtLightSensitivity: + case ECamDynamicSettingFaceTracking: + case ECamDynamicSettingOpticalJoyStick: + case ECamDynamicSettingOneClickUpload: + case ECamDynamicSettingVideoLight: + case ECamDynamicSettingAutoFocus: + case ECamDynamicSettingVideoStabilization: + case ECamDynamicSettingOrientationSensor: + case ECamDynamicSetting2ndCameraOrientation: + case ECamDynamicSettingUIOrientationOverride: + case ECamDynamicSettingThumbnailManagerAPI: + case ECamDynamicSettingBurstMode: + case ECamDynamicSettingContinuousAF: + case ECamDynamicSettingBurstFileSizeEstimateFactor: + case ECamDynamicSettingCustomCaptureButton: + { + PRINT1( _L("Camera <> CCameraUiConfigManagerImp::LoadAllDynamicSettingsL() append %d" ), settingId ) + AppendToSettingsArrayL( settingId, + supportedValue, + settingItemDefaultData ); + break; + } + case ECamDynamicSettingVideoSceneModeNormal: + case ECamDynamicSettingVideoSceneModeNight: + case ECamDynamicSettingVideoSceneModeLowLight: + case ECamDynamicSettingDSAViewFinder: + case ECamDynamicSettingImageSceneModeAuto: + case ECamDynamicSettingImageSceneModeUser: + case ECamDynamicSettingImageSceneModeMacro: + case ECamDynamicSettingImageSceneModePotrait: + case ECamDynamicSettingImageSceneModeScenery: + case ECamDynamicSettingImageSceneModeSports: + case ECamDynamicSettingImageSceneModeNight: + case ECamDynamicSettingImageSceneModeNightPotrait: + case ECamDynamicSettingPCCaptureKeys: + case ECamDynamicSettingSCCaptureKeys: + case ECamDynamicSettingPCAutoFocusKeys: + case ECamDynamicSettingSCAutoFocusKeys: + case ECamDynamicSettingPCZoomIn: + case ECamDynamicSettingSCZoomIn: + case ECamDynamicSettingPCZoomOut: + case ECamDynamicSettingSCZoomOut: + case ECamDynamicSettingWhiteBalance: + case ECamDynamicSettingColorTone: + case ECamDynamicSettingContrast: + case ECamDynamicSettingBrightness: + case ECamDynamicSettingEV: + case ECamDynamicSettingSharpness: + case ECamDynamicSettingFlashMode: + case ECamDynamicSettingZoomLAF: + case ECamDynamicSettingMaxOpticalZoomLimits: + case ECamDynamicSettingMaxExtendedZoomLimits: + case ECamDynamicSettingMaxDigitalZoomLimits: + case ECamDynamicSettingZoomDelays: + case ECamDynamicSettingScreenModes: + { + PRINT1( _L("Camera <> CCameraUiConfigManagerImp::LoadAllDynamicSettingsL() %d" ), settingId ) + LoadConfiguredSettingItemValuesFromCrL( settingId, + supportedValue, + settingItemDefaultData ); + break; + } + default: + { + break; + } + + } + } + CleanupStack::PopAndDestroy( &settingItemDefaultData ); + User::LeaveIfError( error ); + PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadAllDynamicSettingsL()" )) + } + + + +// +//CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCr +// +void CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCrL( + const TInt aSettingId, + const TInt aSupportedValue, + RArray& aDefaultItems ) + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCrL" )) + // Load supported setting items only when feature is supported + LoadDefaultSettingsDataL( aSettingId, aDefaultItems ); + AppendToSettingsArrayL( aSettingId, + aSupportedValue, + aDefaultItems, + MapSettingItemToCrItemsKeyL( aSettingId ), + ETrue ); + PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCrL" )) + } + + + + +// +// CCameraUiConfigManagerImp::AppendToSettingsArrayL +// +void CCameraUiConfigManagerImp::AppendToSettingsArrayL( const TInt aItemId, + const TInt aSupportedValue, + RArray& aAllItems, + TUint32 aCrItemsKey, + TBool aLoadSettingItems ) + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::AppendToSettingsArrayL" )) + TSupportedSettingsData* newSetting = new( ELeave ) TSupportedSettingsData; + CleanupStack::PushL( newSetting ); + + newSetting->iSettingId = aItemId; // setting id + newSetting->iSupportedValue = aSupportedValue; // feature support + if ( aLoadSettingItems && aSupportedValue ) + { + // all configured setting items from cr only if the feature is supported + GetSupportedSettingIdsL( aAllItems, + newSetting->iSupportedSettingItems, + aCrItemsKey ); + } + + iSupportedSettings.AppendL( newSetting ); + CleanupStack::Pop( newSetting ); + PRINT( _L("Camera <= CCameraUiConfigManagerImp::AppendToSettingsArrayL" )) + } + + + +// --------------------------------------------------------------------------- +// CCameraUiConfigManager::LoadAllDynamicSettingL +// Load all dynamic settings +// --------------------------------------------------------------------------- +// +void CCameraUiConfigManagerImp::LoadDefaultSettingsDataL( + const TInt aSettingId, + RArray& aDefaultItems ) + { + PRINT1( _L("Camera => CCameraUiConfigManagerImp::LoadDefaultSettingsDataL setting id [%d]" ), aSettingId ) + aDefaultItems.Reset(); + TInt i = 0; + const TInt* settingsId = LoadSettingEnumerationArray( aSettingId ); + const TUint16* const* stringArray = LoadSettingStringArray( aSettingId ); + + if ( settingsId && stringArray ) + { + while ( settingsId[i] != KCamLastSettingItem ) + { + TDynamicSettingsData data; + data.iItemId = settingsId[i]; + data.iText = stringArray[i]; + aDefaultItems.AppendL( data ); + i++; + } + } + PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadDefaultSettingsDataL()" ) ) + } + + + +// +// CCameraUiConfigManagerImp::GetSupportedSettingIdsL +// +void CCameraUiConfigManagerImp::GetSupportedSettingIdsL( + RArray& aAllItems, + RArray& aSupportedValues, + const TUint32 aCrKey ) + { + PRINT( _L("Camera => CameraUiConfigManagerImp::GetSupportedSettingIdsL" )) + aSupportedValues.Reset(); + + HBufC* string; // not sure but does this need to be in cleanupstack since this can later leave? + string = GetStringDataL( aCrKey ); + TBool clearstring = EFalse; + + TPtrC data = string->Des(); + TPtrC currentItem( KNullDesC ); + + while ( data.Length() > 0 ) + { + // Find the next instance of item separator + const TInt separatorIndex( data.Find( KItemsSeparator ) ); + + if( KErrNotFound != separatorIndex ) + { + // There is more than one item in the string still + // Get the current item - everything before separator + currentItem.Set( data.Left( separatorIndex ) ); + // The remaining data is now everything after the separator + data.Set( data.Right( data.Length() - separatorIndex - 1 ) ); + } + else + { + // This is the last item in the string + currentItem.Set( data ); + data.Set( KNullDesC ); + clearstring = ETrue; + } + + // Get the item id for the current item, and if found, append to list + TInt settingItem; + PRINT1( _L("Camera <> settingItem: %S"), string ) + if ( currentItem[0]-48 >= 0 && currentItem[0]-48 <= 9 || + ( currentItem[0] == '-' && // check for negative number too + currentItem[1]-48 >= 0 && currentItem[1]-48 <= 9 ) ) + { + // read the numeric value equivalent to the numeric string + TLex lex; + if( currentItem.Length() > 2 ) + { + // if it is hex value, then extract hex value + if( currentItem[1] == 'x' || currentItem[1] == 'X' ) + { + lex = TLex( currentItem.Mid(2) ); + TRadix radix = EHex; + TUint value; + lex.Val(value, radix); + settingItem = value; + } + else // extract integer + { + lex = TLex( currentItem ); + lex.Val( settingItem ); + } + } + else // extract integer + { + lex = TLex( currentItem ); + lex.Val( settingItem ); + } + } + else + { + // not a numeric string, check for necessary enum equivalents. + settingItem = SettingItemId( aAllItems, currentItem ); + } + + PRINT1( _L("Camera <> settingItem: %d"), settingItem ) + + if( KErrNotFound != settingItem ) + { + aSupportedValues.AppendL( settingItem ); // here + } + if( clearstring ) + { + delete string; + } + } + PRINT( _L("Camera <= CameraUiConfigManagerImp::GetSupportedSettingIdsL" )) + } + + + +// +// CCameraUiConfigManagerImp::SettingItemId +// +TInt CCameraUiConfigManagerImp::SettingItemId( + RArray& aPossibleSettings, + const TDesC& aItemString ) const + { + PRINT( _L("Camera => CameraUiConfigManagerImp::SettingItemId" )) + for( TInt i = aPossibleSettings.Count()-1; i >= 0; i-- ) + { + if( aItemString == aPossibleSettings[i].iText ) + { + PRINT( _L("Camera <= CameraUiConfigManagerImp::SettingItemId" )) + return aPossibleSettings[i].iItemId; + } + } + + PRINT( _L("Camera <= CameraUiConfigManagerImp::SettingItemId" )) + // No id found for the argument string + return KErrNotFound; + } + + +// +// CCameraUiConfigManagerImp::GetStringDataL +// +HBufC* CCameraUiConfigManagerImp::GetStringDataL( const TUint32 aCrKey ) + { + PRINT( _L("Camera => CameraUiConfigManagerImp::GetStringDataL" )) + HBufC* string = HBufC::NewLC( KCamCRStringInitialLength ); + + TPtr ptr = string->Des(); + TInt size = 0; + TInt status = iRepository->Get( aCrKey, ptr, size ); + + // Did not fit into the string, reserve more memory and try again + if( KErrOverflow == status ) + { + CleanupStack::PopAndDestroy( string ); // String + string = HBufC::NewLC( size ); + ptr = string->Des(); + status = iRepository->Get( aCrKey, ptr, size ); + } + + CleanupStack::Pop( string ); // string + User::LeaveIfError( status ); + + PRINT( _L("Camera <= CameraUiConfigManagerImp::GetStringDataL" )) + return string; + } + + + +// --------------------------------------------------------------------------- +// CCameraUiConfigManager::SearchInSettingsListFor +// Searches in a settings list for a particular setting item. +// --------------------------------------------------------------------------- +// +TInt CCameraUiConfigManagerImp::SearchInSettingsListFor( + const RPointerArray& aSettingsList, + TInt aSettingItem ) const + { + return aSettingsList.Find( aSettingItem, SettingIdMatches ); + } + + +// +//CCameraUiConfigManagerImp::MapSettingItemToCrFeatureKeyL +// +TUint32 CCameraUiConfigManagerImp::MapSettingItemToCrFeatureKeyL( + const TInt aSettingItem ) const + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::MapSettingItemToCrFeatureKeyL" )) + TUint32 crKey( 0 ); + switch ( aSettingItem ) + { + case ECamDynamicSettingRequiredRamMemory: + crKey = KCamCrFeatureRequiredRamMemory; + break; + case ECamDynamicSettingCaptureToneDelaySupport: + crKey = KCamCrFeatureCaptureToneDelaySupport; + break; + case ECamDynamicSettingCaptureToneDelayValue: + crKey = KCamCrFeatureCaptureToneDelayValue; + break; + case ECamDynamicSettingCriticalLevelRamMemory: + crKey = KCamCrFeatureCriticalLevelRamMemory; + break; + case ECamDynamicSettingRequiredRamMemoryFocusGained: + crKey = KCamCrFeatureRequiredRamMemoryFocusGained; + break; + case ECamDynamicSettingCriticalLevelRamMemoryFocusGained: + crKey = KCamCrFeatureCriticalLevelRamMemoryFocusGained; + break; + case ECamDynamicSettingPhoto: + crKey = KCamCrFeatureKeyPhotos; + break; + case ECamDynamicSettingPublishZoomState: + crKey = KCamCrFeatureKeyPublishZoomSate; + break; + case ECamDynamicSettingAutofocusSetInHyperfocalAtStartup: + crKey = KCamCrFeatureKeyAFSetInHyperfocalAtStartup; + break; + case ECamDynamicSettingExtDigitalZoom: + crKey = KCamCrFeatureExtDigitalZoom; + break; + case ECamDynamicSettingLocation: + crKey = KCamCrFeatureLocation; + break; + case ECamDynamicSettingKeyLockWatcher: + crKey = KCamCrFeatureKeyLockWatcher; + break; + case ECamDynamicSettingColorTone: + crKey = KCamCrFeatureColorTone; + break; + case ECamDynamicSettingSharpness: + crKey = KCamCrFeatureSharpness; + break; + case ECamDynamicSettingWhiteBalance: + crKey = KCamCrFeatureWhiteBalance; + break; + case ECamDynamicSettingSecondaryCamera: + crKey = KCamCrFeatureSecondaryCamera; + break; + case ECamDynamicSettingLensCover: + crKey = KCamCrFeatureLensCover; + break; + case ECamDynamicSettingXenonFlash: + crKey = KCamCrFeatureXenonFlash; + break; + case ECamDynamicSettingOneClickUpload: + crKey = KCamCrFeatureOneClickUpLoad; + break; + case ECamDynamicSettingVideoLight: + crKey = KCamCrFeatureVideoLight; + break; + case ECamDynamicSettingAutoFocus: + crKey = KCamCrFeatureAutoFocus; + break; + case ECamDynamicSettingExtLightSensitivity: + crKey = KCamCrFeatureExtLightSensitivity; + break; + case ECamDynamicSettingContrast: + crKey = KCamCrFeatureContrast; + break; + case ECamDynamicSettingBrightness: + crKey = KCamCrFeatureBrightness; + break; + case ECamDynamicSettingEV: + crKey = KCamCrFeatureEV; + break; + case ECamDynamicSettingFlashMode: + crKey = KCamCrFeatureFlashMode; + break; + case ECamDynamicSettingLightSensitivity: + crKey = KCamCrFeatureLightSensitivity; + break; + case ECamDynamicSettingVideoStabilization: + crKey = KCamCrFeatureVideoStabilization; + break; + case ECamDynamicSettingOrientationSensor: + crKey = KCamCrFeatureOrientationSensor; + break; + case ECamDynamicSettingFaceTracking: + crKey = KCamCrFeatureFaceTracking; + break; + case ECamDynamicSettingOpticalJoyStick: + crKey = KCamCrFeatureOpticalJoyStick; + break; + case ECamDynamicSetting2ndCameraOrientation: + crKey = KCamCrFeature2ndCameraOrientation; + break; + case ECamDynamicSettingUIOrientationOverride: + crKey = KCamCrFeatureUIOrientationOverride; + break; + case ECamDynamicSettingThumbnailManagerAPI: + crKey = KCamCrFeatureThumbnailManagerAPI; + break; + case ECamDynamicSettingBurstFileSizeEstimateFactor: + crKey = KCamCrFeatureBurstFileSizeEstimateFactor; + break; + case ECamDynamicSettingBurstMode: + crKey = KCamCrFeatureBurstMode; + break; + case ECamDynamicSettingContinuousAF: + crKey = KCamCrFeatureContinuousAF; + break; + case ECamDynamicSettingCustomCaptureButton: + crKey = KCamCrFeatureCustomCaptureButton; + break; + default: + PRINT( _L("Camera <> CCameraUiConfigManagerImp::MapSettingItemToCrFeatureKeyL, leave!!!" ) ) + User::Leave( KErrNotSupported ); + } + PRINT( _L("Camera <= CCameraUiConfigManagerImp::MapSettingItemToCrFeatureKeyL" ) ) + return crKey; + } + + + +// +//CCameraUiConfigManagerImp::MapSettingItemToCrKeyL +// +TUint32 +CCameraUiConfigManagerImp::MapSettingItemToCrItemsKeyL( const TInt aSettingItem ) const + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::MapSettingItemToCrItemsKeyL" )) + TUint32 crKey( 0 ); + switch ( aSettingItem ) + { + case ECamDynamicSettingVideoSceneModeNormal: + crKey = KCamCrFeatureVideoSceneNormal; + break; + case ECamDynamicSettingVideoSceneModeNight: + crKey = KCamCrFeatureVideoSceneModeNight; + break; + case ECamDynamicSettingVideoSceneModeLowLight: + crKey = KCamCrFeatureVideoSceneModeLowLight; + break; + case ECamDynamicSettingDSAViewFinder: + crKey = KCamCrFeatureDSAViewFinder; + break; + case ECamDynamicSettingImageSceneModeAuto: + crKey = KCamCrFeatureImageSceneModeAuto; + break; + case ECamDynamicSettingImageSceneModeUser: + crKey = KCamCrFeatureImageSceneModeUser; + break; + case ECamDynamicSettingImageSceneModeMacro: + crKey = KCamCrFeatureImageSceneModeMacro; + break; + case ECamDynamicSettingImageSceneModePotrait: + crKey = KCamCrFeatureImageSceneModePotrait; + break; + case ECamDynamicSettingImageSceneModeScenery: + crKey = KCamCrFeatureImageSceneModeScenery; + break; + case ECamDynamicSettingImageSceneModeSports: + crKey = KCamCrFeatureImageSceneModeSports; + break; + case ECamDynamicSettingImageSceneModeNight: + crKey = KCamCrFeatureImageSceneModeNight; + break; + case ECamDynamicSettingImageSceneModeNightPotrait: + crKey = KCamCrFeatureImageSceneModeNightPotrait; + break; + case ECamDynamicSettingPCCaptureKeys: + crKey = KCamCrFeaturePCCaptureKeys; + break; + case ECamDynamicSettingSCCaptureKeys: + crKey = KCamCrFeatureSCCaptureKeys; + break; + case ECamDynamicSettingPCAutoFocusKeys: + crKey = KCamCrFeaturePCAutoFocusKeys; + break; + case ECamDynamicSettingSCAutoFocusKeys: + crKey = KCamCrFeatureSCAutoFocusKeys; + break; + case ECamDynamicSettingColorTone: + crKey = KCamCrFeatureColorToneItems; + break; + case ECamDynamicSettingWhiteBalance: + crKey = KCamCrFeatureWhiteBalanceItems; + break; + case ECamDynamicSettingPCZoomIn: + crKey = KCamCrFeaturePCZoomInItems; + break; + case ECamDynamicSettingPCZoomOut: + crKey = KCamCrFeaturePCZoomOutItems; + break; + case ECamDynamicSettingSCZoomIn: + crKey = KCamCrFeatureSCZoomInItems; + break; + case ECamDynamicSettingSCZoomOut: + crKey = KCamCrFeatureSCZoomOutItems; + break; + case ECamDynamicSettingEV: + crKey = KCamCrFeatureEVItems; + break; + case ECamDynamicSettingSharpness: + crKey = KCamCrFeatureSharpnessItems; + break; + case ECamDynamicSettingFlashMode: + crKey = KCamCrFeatureFlashModeItems; + break; + case ECamDynamicSettingMaxDigitalZoomLimits: + crKey = KCamCrFeatureMaxDigitalZoomLimits; + break; + case ECamDynamicSettingMaxExtendedZoomLimits: + crKey = KCamCrFeatureMaxExtendedZoomLimits; + break; + case ECamDynamicSettingMaxOpticalZoomLimits: + crKey = KCamCrFeatureMaxOpticalZoomLimits; + break; + case ECamDynamicSettingZoomLAF: + crKey = KCamCrFeatureZoomLAF; + break; + case ECamDynamicSettingContrast: + crKey = KCamCrFeatureContrastItems; + break; + case ECamDynamicSettingBrightness: + crKey = KCamCrFeatureBrightnessItems; + break; + case ECamDynamicSettingZoomDelays: + crKey = KCamCrFeatureZoomDelays; + break; + case ECamDynamicSettingScreenModes: + crKey = KCamCrFeatureScreenModes; + break; + default: + PRINT( _L("Camera <> CCameraUiConfigManagerImp::MapSettingItemToCrItemsKeyL, leave!!!" ) ) + User::Leave( KErrNotSupported ); + } + PRINT( _L("Camera <= CCameraUiConfigManagerImp::MapSettingItemToCrItemsKeyL" ) ) + return crKey; + } + + +// +//CCameraUiConfigManagerImp::LoadCrForFeatureSupport +// +TBool CCameraUiConfigManagerImp::LoadCrForFeatureSupport( const TInt aSettingId ) const + { + TBool loadFromCr( ETrue ); + + switch ( aSettingId ) + { + case ECamDynamicSettingDSAViewFinder: + case ECamDynamicSettingPCCaptureKeys: + case ECamDynamicSettingSCCaptureKeys: + case ECamDynamicSettingPCAutoFocusKeys: + case ECamDynamicSettingSCAutoFocusKeys: + case ECamDynamicSettingPCZoomIn: + case ECamDynamicSettingPCZoomOut: + case ECamDynamicSettingSCZoomIn: + case ECamDynamicSettingSCZoomOut: + case ECamDynamicSettingMaxDigitalZoomLimits: + case ECamDynamicSettingMaxExtendedZoomLimits: + case ECamDynamicSettingMaxOpticalZoomLimits: + case ECamDynamicSettingZoomLAF: + case ECamDynamicSettingImageSceneModeAuto: + case ECamDynamicSettingImageSceneModeUser: + case ECamDynamicSettingImageSceneModeMacro: + case ECamDynamicSettingImageSceneModePotrait: + case ECamDynamicSettingImageSceneModeScenery: + case ECamDynamicSettingImageSceneModeSports: + case ECamDynamicSettingImageSceneModeNight: + case ECamDynamicSettingImageSceneModeNightPotrait: + case ECamDynamicSettingVideoSceneModeNormal: + case ECamDynamicSettingVideoSceneModeNight: + case ECamDynamicSettingVideoSceneModeLowLight: + case ECamDynamicSettingZoomDelays: + case ECamDynamicSettingScreenModes: + loadFromCr = EFalse; + break; + default: + break; + } + return loadFromCr; + } + +// +//CCameraUiConfigManagerImp::LoadSettingEnumerationArray +// +const TInt* CCameraUiConfigManagerImp::LoadSettingEnumerationArray( const TInt aSettingItem ) + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::LoadSettingEnumerationArray" ) ) + const TInt* enumArray = NULL; + + switch ( aSettingItem ) + { + case ECamDynamicSettingWhiteBalance: + enumArray = KCamWhiteBalanceEnums; + break; + case ECamDynamicSettingColorTone: + enumArray = KCamColorToneEnums; + break; + case ECamDynamicSettingFlashMode: + enumArray = KCamFlashModeEnums; + break; + case ECamDynamicSettingImageSceneModeAuto: + case ECamDynamicSettingImageSceneModeUser: + case ECamDynamicSettingImageSceneModeMacro: + case ECamDynamicSettingImageSceneModePotrait: + case ECamDynamicSettingImageSceneModeScenery: + case ECamDynamicSettingImageSceneModeSports: + case ECamDynamicSettingImageSceneModeNight: + case ECamDynamicSettingImageSceneModeNightPotrait: + case ECamDynamicSettingVideoSceneModeNormal: + case ECamDynamicSettingVideoSceneModeNight: + case ECamDynamicSettingVideoSceneModeLowLight: + enumArray = KCamSceneModeEnums; + break; + default: + PRINT( _L("Camera <> CCameraUiConfigManagerImp::LoadSettingEnumerationArray, default!!!" ) ) + break; + } + PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadSettingEnumerationArray" ) ) + return enumArray; + } + + +// +//CCameraUiConfigManagerImp::LoadSettingStringArray +// +const TUint16* const* CCameraUiConfigManagerImp::LoadSettingStringArray( + const TInt aSettingItem ) + { + PRINT( _L("Camera => CCameraUiConfigManagerImp::LoadSettingStringArray()" ) ) + const TUint16* const* stringArray = NULL; + + switch ( aSettingItem ) + { + case ECamDynamicSettingWhiteBalance: + stringArray = KCamWhiteBalanceStrings; + break; + case ECamDynamicSettingColorTone: + stringArray = KCamColorToneStrings; + break; + case ECamDynamicSettingFlashMode: + stringArray = KCamFlashModeStrings; + break; + case ECamDynamicSettingImageSceneModeAuto: + case ECamDynamicSettingImageSceneModeUser: + case ECamDynamicSettingImageSceneModeMacro: + case ECamDynamicSettingImageSceneModePotrait: + case ECamDynamicSettingImageSceneModeScenery: + case ECamDynamicSettingImageSceneModeSports: + case ECamDynamicSettingImageSceneModeNight: + case ECamDynamicSettingImageSceneModeNightPotrait: + case ECamDynamicSettingVideoSceneModeNormal: + case ECamDynamicSettingVideoSceneModeNight: + case ECamDynamicSettingVideoSceneModeLowLight: + stringArray = KCamSceneModeStrings; + break; + default: + break; + } + PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadSettingStringArray()" ) ) + return stringArray; + } + + +/* +* Organizing CenRep data to a definite structure for scene modes. +*/ +void CCameraUiConfigManagerImp::OrganiseSceneSettings( + RArray& aTargetArray, + RArray& aSceneSettingsArray, + const TBool aPhotoScene ) + { + if ( aSceneSettingsArray.Count() > 0 ) + { + TSceneSettings scene; + TInt index = 0; + // The following is the order how we read values from CenRep + // each time for each specific scene mode in Image & Video case. + scene.iSupported = aSceneSettingsArray[index++]; + scene.iIdentifier = aSceneSettingsArray[index++]; + scene.iExposureMode = aSceneSettingsArray[index++]; + scene.iWhiteBalance = aSceneSettingsArray[index++]; + scene.iFlash = aSceneSettingsArray[index++]; + scene.iContrastMode = aSceneSettingsArray[index++]; + scene.iFocalDistance = aSceneSettingsArray[index++]; + + if ( aPhotoScene ) + { + // The following is the order how we read values from CenRep + // each time for each specific scene mode in Image case. + // Note: In image scene, we ignore iFrameRate as this wont be configured + // for any of the image scenes + scene.iSharpnessMode = aSceneSettingsArray[index++]; + scene.iLightSensitivityMode = aSceneSettingsArray[index++]; + scene.iExposureCompensationValue = aSceneSettingsArray[index++]; + } + else + { + // The following is the order how we read values from CenRep + // each time for each specific scene mode in Video scene case. + // Note: In image scene, we ignore iFrameRate as this wont be configured + // for any of the image scenes + scene.iFrameRate = aSceneSettingsArray[index++]; + } + aTargetArray.Append( scene ); + } + } +// End of file