camerauis/cameraapp/generic/camerauiconfigmanager/src/CameraUiConfigManagerImp.cpp
/*
* 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 <StringLoader.h>
#include <barsread.h>
#include <e32base.h>
#include <e32const.h>
#include <centralrepository.h>
#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<TInt>( 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<TInt>& aSupportedValues )
{
PRINT( _L("Camera => CCameraUiConfigManagerImp::SupportedSettingItemsL" ))
TInt settingIndex ( KErrNotFound );
aSupportedValues.Reset();
if ( iSupportedSettings.Count() > 0 )
{
settingIndex = SearchInSettingsListFor( iSupportedSettings,
static_cast<TInt>( 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<TDynamicSettingsData> settingItemDefaultData;
CleanupClosePushL( settingItemDefaultData );
TInt supportedValue = 0;
TInt error = KErrNone;
for( TInt settingId = ( static_cast<TInt>( ECamDynamicSettingsMin ) + 1 );
settingId < static_cast<TInt>( 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<TDynamicSettingsData>& 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<TDynamicSettingsData>& 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<TDynamicSettingsData>& 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<TDynamicSettingsData>& aAllItems,
RArray<TInt>& 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<TDynamicSettingsData>& 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<TSupportedSettingsData>& 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<TSceneSettings>& aTargetArray,
RArray<TInt>& 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