diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/common/src/CamStaticSettingsModel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/common/src/CamStaticSettingsModel.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,1237 @@ +/* +* Copyright (c) 2007 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: Manages all static settings data.* +*/ + + + +// =========================================================================== +// Includes + +#include +#include +#include +#include +#ifndef CAMERAAPP_PLUGIN_BUILD +#include +#include +#include "camsettingconversion.h" +#else +#include +#endif + +#include "CamStaticSettingsModel.h" +#include "CamUtility.h" +#include "CamPanic.h" +#include "CamAppUiBase.h" +#include "CamVideoQualityLevel.h" +#include "CameraappPrivateCRKeys.h" // CR keys +#include "CameraUiConfigManager.h" +#include "camconfiguration.h" + + +// =========================================================================== +// Constants + +const TInt KCamCRStringInitialLength = 64; +const TInt KCamUseDefaultVideoQuality = -1; + +// =========================================================================== +// Local methods + +inline TBool SettingIdMatches( const TInt* aSettingId, + const TIntSetting& aSettingItem ) + { + return (*aSettingId == aSettingItem.iItemId); + }; + + +// =========================================================================== +// Class methods + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::NewL +// Symbian OS two-phased constructor +// --------------------------------------------------------------------------- +// +CCamStaticSettingsModel* +CCamStaticSettingsModel::NewL( CCamConfiguration& aConfiguration ) + { + CCamStaticSettingsModel* self + = CCamStaticSettingsModel::NewLC( aConfiguration ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::NewLC +// Symbian OS two-phased constructor +// --------------------------------------------------------------------------- +// +CCamStaticSettingsModel* +CCamStaticSettingsModel::NewLC( CCamConfiguration& aConfiguration ) + { + CCamStaticSettingsModel* self + = new( ELeave ) CCamStaticSettingsModel( aConfiguration ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::IntegerSettingValue +// Returns the current integer value for the specified setting +// --------------------------------------------------------------------------- +// +TInt +CCamStaticSettingsModel::IntegerSettingValue( TInt aSettingItem ) const + { + TInt value = KErrNotFound; + const RPointerArray *iStaticIntSettings=NULL; + // If setting item is in the static photo settings return it's value. + if( ECamSettingItemStaticPhotoRangeMax > aSettingItem + && ECamSettingItemStaticPhotoRangeMin < aSettingItem ) + { + iStaticIntSettings=&iStaticPhotoIntSettings; + } + // Otherwise, if setting item is in the static video settings return it's value. + else if( ECamSettingItemStaticVideoRangeMax > aSettingItem + && ECamSettingItemStaticVideoRangeMin < aSettingItem ) + { + iStaticIntSettings=&iStaticVideoIntSettings; + } + // Look in static common settings. + else if( ECamSettingItemStaticCommonRangeMax > aSettingItem + && ECamSettingItemStaticCommonRangeMin < aSettingItem ) + { + iStaticIntSettings=&iStaticCommonIntSettings; + } + else + { + PRINT( _L("Camera <> Not found, PANIC !! ECamPanicUnknownSettingItem" )) + CamPanic( ECamPanicUnknownSettingItem ); + } + + if( iStaticIntSettings ) + { + TInt settingIndex = SearchInSettingsListFor( + *iStaticIntSettings, + aSettingItem ); + if( settingIndex < iStaticIntSettings->Count() && settingIndex >= 0 ) + { + value = (*iStaticIntSettings)[settingIndex]->iValueId; + } + } + return value; + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SetIntegerSettingValueL +// Sets a new integer value for the specified setting +// --------------------------------------------------------------------------- +// +void +CCamStaticSettingsModel::SetIntegerSettingValueL( TInt aSettingItem, + TInt aSettingValue ) + { + TCamSettingItemIds settingId( + static_cast(aSettingItem) ); + + // Static image settings + if( ECamSettingItemStaticPhotoRangeMin < settingId + && ECamSettingItemStaticPhotoRangeMax > settingId ) + { + PRINT( _L("Camera <> static photo setting") ); + TInt settingIndex = SearchInSettingsListFor( iStaticPhotoIntSettings, settingId ); + iStaticPhotoIntSettings[settingIndex]->iValueId = aSettingValue; + SaveStaticSettingL( settingId ); + + // Video / photo storage settings follow eachother + if ( ECamSettingItemPhotoMediaStorage == settingId ) + { + TInt index = SearchInSettingsListFor( iStaticVideoIntSettings, + ECamSettingItemVideoMediaStorage ); + if ( index != KErrNotFound ) + { + iStaticVideoIntSettings[index]->iValueId = aSettingValue; + SaveStaticSettingL( ECamSettingItemVideoMediaStorage ); + } + } + } + // ------------------------------------------------------- + // Static video settings + else if( ECamSettingItemStaticVideoRangeMin < settingId + && ECamSettingItemStaticVideoRangeMax > settingId ) + { + TInt settingIndex = SearchInSettingsListFor( iStaticVideoIntSettings, settingId ); + iStaticVideoIntSettings[settingIndex]->iValueId = aSettingValue; + SaveStaticSettingL( settingId ); + + // Video / photo storage settings follow eachother + if ( ECamSettingItemVideoMediaStorage == settingId ) + { + TInt index = SearchInSettingsListFor( iStaticPhotoIntSettings, + ECamSettingItemPhotoMediaStorage ); + if ( index != KErrNotFound ) + { + iStaticPhotoIntSettings[index]->iValueId = aSettingValue; + SaveStaticSettingL( ECamSettingItemPhotoMediaStorage ); + } + } + } + // ------------------------------------------------------- + // Static common settings + else if( ECamSettingItemStaticCommonRangeMin < settingId + && ECamSettingItemStaticCommonRangeMax > settingId ) + { + TInt settingIndex = SearchInSettingsListFor( iStaticCommonIntSettings, settingId ); + iStaticCommonIntSettings[settingIndex]->iValueId = aSettingValue; + SaveStaticSettingL( settingId ); + } + // ------------------------------------------------------- + else + { + // Ignored at the moment + PRINT( _L("Camera <> Setting item not found !!!") ); + } + // ------------------------------------------------------- + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SetTextSettingValueL +// Sets a new text value for the specified setting +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::SetTextSettingValueL( TInt aSettingItem, + const TDesC& aSettingValue ) + { +switch ( aSettingItem ) + { + case ECamSettingItemPhotoNameBase: + { + iPhotoBaseName = aSettingValue; + break; + } + case ECamSettingItemVideoNameBase: + { + iVideoBaseName = aSettingValue; + break; + } + case ECamSettingItemDefaultAlbumName: + { + iDefaultAlbumName = aSettingValue; + break; + } + default: + { + PRINT( _L("Camera <> CCamSettingsModel::ECamPanicUnknownSettingItem 4" )) + CamPanic( ECamPanicUnknownSettingItem ); + return; + } + } + SaveStaticSettingL( static_cast(aSettingItem) ); + } + + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::TextSettingValue +// Returns the current text value for the specified setting +// --------------------------------------------------------------------------- +// +TPtrC CCamStaticSettingsModel::TextSettingValue( TInt aSettingItem ) const + { + switch ( aSettingItem ) + { + case ECamSettingItemPhotoNameBase: return iPhotoBaseName; + case ECamSettingItemVideoNameBase: return iVideoBaseName; + case ECamSettingItemDefaultAlbumName: return iDefaultAlbumName; + default: + { + PRINT( _L("Camera =><= CCamSettingsModel::TextSettingValue, PANIC!!!" ) ); + CamPanic( ECamPanicUnknownSettingItem ); + } + } + return NULL; + } + +#ifndef CAMERAAPP_PLUGIN_BUILD +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::LoadStaticSettingsL +// Loads the static settings from shared data. Required to update +// the settings whenever get foreground event, incase of external +// changes to the settings. +// Note that static settings cannot be loaded until the AppUi has been created, +// as which settings to use is dependent on if app is embedded or not. +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::LoadStaticSettingsL( TBool aIsEmbedded ) + { + PRINT(_L("Camera => CCamStaticSettingsModel::LoadStaticSettingsL" )) + iEmbedded = aIsEmbedded; + + // Free all memory currently used by the static settings. + UnloadStaticSettings(); + + // Settings that depend on embedded status + // If this application is embedded in MMS load + // the embedded defaults for static settings. +#ifndef CAMERAAPP_PLUGIN_BUILD + if ( iEmbedded ) + { + LoadEmbeddedSettingsL(); + } +#endif //CAMERAAPP_PLUGIN_BUILD + + // Settings that *do not* depend on embedded status + LoadPhotoStaticSettingsL( EFalse ); + LoadVideoStaticSettingsL( EFalse ); + LoadCommonStaticSettingsL( EFalse ); + + PRINT(_L("Camera <= CCamSettingsModel::LoadStaticSettingsL" )) + } + +#endif //#ifndef CAMERAAPP_PLUGIN_BUILD + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::ReadCenRepIntL +// Reads the specified setting from Central Repository to the specified +// settings model array +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::ReadFromCenRepL( const TInt aMinRange, + const TInt aMaxRange, + RPointerArray & aArray ) + { + TUint32 crKey; + TBool ignore(EFalse); + for ( TInt i = aMinRange+1; i < aMaxRange; i++ ) + { + ignore = EFalse; + if ( i == ECamSettingItemPhotoNameBase ) + { + LoadPhotoBaseNameL(); + } + else if ( i == ECamSettingItemVideoNameBase ) + { + LoadVideoBaseNameL(); + } + else if ( i == ECamSettingItemDefaultAlbumName ) + { + LoadDefaultAlbumNameL(); + } + else + { + /* + * Settings that depend on embedded status, we ignore reading the settings + * if we are loading settings for embedded camera. + */ + if ( iEmbedded && + ( i == ECamSettingItemPhotoQuality || + i == ECamSettingItemShowCapturedPhoto || + i == ECamSettingItemVideoQuality || + i == ECamSettingItemVideoShowCapturedVideo || + i == ECamSettingItemVideoAudioRec ) ) + { + ignore = ETrue; + } + if ( !ignore ) + { + crKey = MapSettingItem2CRKey( static_cast( i ), + iEmbedded ); + ReadCenRepIntL( static_cast( i ), + crKey, + aArray ); + } + } + } + } + + +#ifndef CAMERAAPP_PLUGIN_BUILD +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::LoadEmbeddedSettingsL(); +// Reads the specified setting from Central Repository to the specified +// settings model array +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::LoadEmbeddedSettingsL() + { + LoadSettingsFromResourceL( R_CAM_PHOTO_EMBEDDED_STATIC_SETTINGS_DATA, + iStaticPhotoIntSettings ); + LoadSettingsFromResourceL( R_CAM_VIDEO_EMBEDDED_STATIC_SETTINGS_DATA, + iStaticVideoIntSettings ); + + // Video - Record Audio (not shared with standalone) + ReadCenRepIntL( ECamSettingItemVideoAudioRec, + KCamCrEmbeddedVideoAudRec, + iStaticVideoIntSettings ); + + TIntSetting* newSetting = new (ELeave) TIntSetting; + CleanupStack::PushL( newSetting ); + + // Read the data for this setting item from resource. + newSetting->iItemId = ECamSettingItemPhotoQuality; + + CCamAppUiBase* appUi = 0; + TSize requiredReso, requiredResolution; + // if using the second camera + if( static_cast( + CEikonEnv::Static()->AppUi() )->ActiveCamera() == ECamActiveCameraSecondary ) + { + PRINT(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL Setting secondary camera image quality" )) + newSetting->iValueId = iConfiguration.SecondaryCameraImageQuality(); + } + else + { + appUi = static_cast( CEikonEnv::Static()->AppUi() ); + requiredReso = appUi->RequestedNewFileResolution(); + requiredResolution = iConfiguration.MapRequiredResolutionToActualResolutionPhoto(requiredReso); + if ( requiredResolution == TSize(0,0) ) + { + PRINT(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL Setting mms image quality" )) + newSetting->iValueId = iConfiguration.MmsImageQuality(); + } + else + { + PRINT(_L("Camera <=> CCamStaticSettingsModdel::LoadEmbeddedSettingsL Setting custom image quality")); + TSize resolutionToGet = requiredResolution; + PRINT2(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL image resolutionToGet(%d,%d)"), resolutionToGet.iWidth, resolutionToGet.iHeight ); + TInt QualityIndex = iConfiguration.GetRequiredImageQualityIndex( resolutionToGet ); + PRINT1(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL image QualityIndex: %d"), QualityIndex ); + newSetting->iValueId = iConfiguration.ImageQuality( QualityIndex ).iPhotoQualityId; + PRINT1(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL image newSetting->iValueId: %d"), newSetting->iValueId ); + } + } + + // Add the new setting item and its associated key + // to the parallel arrays for static photo settings. + iStaticPhotoIntSettings.AppendL( newSetting ); + CleanupStack::Pop( newSetting ); + + newSetting = new (ELeave) TIntSetting; + CleanupStack::PushL( newSetting ); + + // Read the data for this setting item from resource. + newSetting->iItemId = ECamSettingItemVideoQuality; + + // if using the second camera + if( static_cast( + CEikonEnv::Static()->AppUi() )->ActiveCamera() == ECamActiveCameraSecondary ) + { + PRINT(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL Setting secondary camera image quality" )) + newSetting->iValueId = iConfiguration.SecondaryCameraVideoQuality(); + } + else + { + appUi = static_cast( CEikonEnv::Static()->AppUi() ); + requiredReso = appUi->RequestedNewFileResolution(); + requiredResolution = iConfiguration.MapRequiredResolutionToActualResolutionVideo(requiredReso); + if ( requiredResolution == TSize(0,0) ) + { + PRINT(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL Setting mms video quality" )) + newSetting->iValueId = iConfiguration.SecondaryCameraVideoQuality(); + } + else + { + TSize resolutionToGet = requiredResolution; + PRINT2(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL resolutionToGet(%d,%d)"), resolutionToGet.iWidth, resolutionToGet.iHeight ); + TInt QualityIndex = iConfiguration.GetRequiredVideoQualityIndex( resolutionToGet ); + PRINT1(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL QualityIndex: %d"), QualityIndex ); + newSetting->iValueId = iConfiguration.VideoQualitySetting( QualityIndex ); + PRINT1(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL newSetting->iValueId: %d"), newSetting->iValueId ); + } + } + + // Add the new setting item and its associated key + // to the parallel arrays for static photo settings. + iStaticVideoIntSettings.AppendL( newSetting ); + CleanupStack::Pop( newSetting ); + } + +#endif //CAMERAAPP_PLUGIN_BUILD + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::ReadCenRepIntL +// Reads the specified setting from Central Repository to the specified +// settings model array +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::ReadCenRepIntL( TCamSettingItemIds aUiId, + TInt aCenRepID, + RPointerArray & aArray ) + { + PRINT2(_L("Camera => CCamStaticSettingsModel::ReadCenRepIntL set id:%d, cenrep id: 0x%02X" ), aUiId, aCenRepID ) + TIntSetting* newSetting = new( ELeave ) TIntSetting; + CleanupStack::PushL( newSetting ); + newSetting->iItemId = aUiId; +#ifndef CAMERAAPP_PLUGIN_BUILD + // if using the second camera, then get the photo\video quality from + // the cached value, not the shared data file + if( ( aUiId == ECamSettingItemPhotoQuality || + aUiId == ECamSettingItemVideoQuality ) && + static_cast( + CEikonEnv::Static()->AppUi() )->ActiveCamera() == ECamActiveCameraSecondary ) + { + if ( aUiId == ECamSettingItemPhotoQuality ) + { + newSetting->iValueId = iSecondaryCameraSettings.iPhotoQuality; + } + else + { + newSetting->iValueId = iSecondaryCameraSettings.iVideoQuality; + } + } + else // get the value from the shared data file +#endif //CAMERAAPP_PLUGIN_BUILD + { + User::LeaveIfError( iRepository->Get( aCenRepID , newSetting->iValueId ) ); + + // When getting the default video qulity, should get the default setting + // from ICM + if(aUiId == ECamSettingItemVideoQuality && + newSetting->iValueId == KCamUseDefaultVideoQuality) + { + newSetting->iValueId = iConfiguration.GetDefaultVideoQualityFromIcmL(); + } + } + + aArray.AppendL( newSetting ); + CleanupStack::Pop( newSetting ); + PRINT(_L("Camera <= CCamStaticSettingsModel::ReadCenRepIntL" )) + } + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SaveCenRepItemL +// Writes the specified setting to the Central Repository +// --------------------------------------------------------------------------- +// +void +CCamStaticSettingsModel::SaveCenRepItemL( + TCamSettingItemIds aItemId, + TInt aCenRepId, + const RPointerArray& aArray ) + { + PRINT( _L("Camera => CCamStaticSettingsModel::SaveCenRepItemL") ); + TInt settingIndex = SearchInSettingsListFor( aArray, aItemId ); + + if ( settingIndex != KErrNotFound ) + { + TInt settingValue = aArray[ settingIndex ]->iValueId; + User::LeaveIfError( iRepository->Set( aCenRepId, settingValue ) ); + } + else + { + User::Leave( settingIndex ); + } + PRINT( _L("Camera <= CCamStaticSettingsModel::SaveCenRepItemL") ); + } + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SaveSettingsL +// Saves the static settings to the shared data ini file +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::SaveSettingsL() + { + // do nothing, from now whenever a setting is changed, + // we call savestaticsettingL. + } + + +// -------------------------------------------- +// CCamStaticSettingsModel::SaveStaticSettingL +// -------------------------------------------- +// +void +CCamStaticSettingsModel::SaveStaticSettingL( TCamSettingItemIds aSettingId ) + { + PRINT( _L("CCamStaticSettingsModel => SaveStaticSettingL") ); + + switch( aSettingId ) + { + // Special cases for text settings. + // KCamCrLastUsedMonthFolder is also in text form, but it cannot be accessed + // with a setting item id. + case ECamSettingItemPhotoNameBase: SavePhotoBaseNameL(); break; + case ECamSettingItemVideoNameBase: SaveVideoBaseNameL(); break; + case ECamSettingItemDefaultAlbumName: SaveDefaultAlbumNameL(); break; + + // Only save photo and video quality for primary camera + case ECamSettingItemPhotoQuality: + { + if ( !iEmbedded ) + { + #ifndef CAMERAAPP_PLUGIN_BUILD + CCamAppUiBase* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + if ( appUi->ActiveCamera() == ECamActiveCameraPrimary ) + #endif //CAMERAAPP_PLUGIN_BUILD + { + SaveCenRepItemL( ECamSettingItemPhotoQuality, + KCamCrPhotoQuality, + iStaticPhotoIntSettings ); + } + } + break; + } + case ECamSettingItemVideoQuality: + { + if ( !iEmbedded ) + { +#ifndef CAMERAAPP_PLUGIN_BUILD + CCamAppUiBase* appUi = static_cast( CEikonEnv::Static()->AppUi() ); + if ( appUi->ActiveCamera() == ECamActiveCameraPrimary ) +#endif //CAMERAAPP_PLUGIN_BUILD + { + SaveCenRepItemL( ECamSettingItemVideoQuality, + KCamCrVideoQuality, + iStaticVideoIntSettings ); + } + } + break; + } + // Text settings which require no special handling + case ECamSettingItemImageToolbarItems: + case ECamSettingItemImageToolbarDefaultItems: + { + TUint32 crKey = MapSettingItem2CRKey( aSettingId, iEmbedded ); + TPtrC value = TextSettingValue( aSettingId ); + + User::LeaveIfError( iRepository->Set( crKey, value ) ); + break; + } + case ECamSettingItemShowCapturedPhoto: + case ECamSettingItemVideoShowCapturedVideo: + { + if ( iEmbedded ) + { + // if in the embedded mode, we dont save value to the CenRep + // because in Embedded mode show photo/video capture setting is + // always on. + return; + } + else + { + } + } + // Integer settings which require no special handling + default: + { + RPointerArray* settingArray = + MapSettingItem2SettingsList( aSettingId ); + + if( settingArray ) + { + TUint32 crKey = MapSettingItem2CRKey( aSettingId, iEmbedded ); + SaveCenRepItemL( aSettingId, crKey, *settingArray ); + } + else + { + CamPanic( ECamPanicUnknownSettingItem ); + } + break; + } + } // switch + + PRINT( _L("CCamStaticSettingsModel <= SaveStaticSettingL") ); + } + + +// --------------------------------------------------------------------------- +// MapSettingItem2CRKey <> +// --------------------------------------------------------------------------- +// +TUint32 +CCamStaticSettingsModel::MapSettingItem2CRKey( TCamSettingItemIds aSettingId, + TBool aEmbedded ) + { + PRINT( _L("Camera => CCamStaticSettingsModel::MapSettingItem2CRKey") ); + TUint32 crKey( 0 ); + + // ------------------------------------------------------- + // static photo settings + if( ECamSettingItemStaticPhotoRangeMin < aSettingId + && ECamSettingItemStaticPhotoRangeMax > aSettingId ) + { + PRINT( _L(" Camera <=> CCamStaticSettingsModel ECamSettingItemStaticPhoto") ); + switch( aSettingId ) + { + case ECamSettingItemPhotoQuality: crKey = KCamCrPhotoQuality; break; + case ECamSettingItemPhotoSize: crKey = KCamCrPhotoSize; break; + case ECamSettingItemPhotoShowFocusPoint: crKey = KCamCrFocusPoint; break; + case ECamSettingItemPhotoStoreInAlbum: crKey = KCamCrPhotoStoreAlbum; break; //KCamCrDefaultAlbumId + case ECamSettingItemShowCapturedPhoto: crKey = KCamCrPhotoShowCaptured; break; + case ECamSettingItemPhotoCaptureTone: crKey = KCamCrPhotoCaptureTone; break; + case ECamSettingItemFaceTracking: crKey = KCamCrPhotoFaceTracking; break; + case ECamSettingItemPhotoMediaStorage: crKey = KCamCrPhotoMemInUse; break; + case ECamSettingItemPhotoNameBase: crKey = KCamCrPhotoNameBase; break; + + case ECamSettingItemPhotoNameBaseType: crKey = KCamCrPhotoNameType; break; + case ECamSettingItemPhotoNumber: crKey = KCamCrPhotoImgCount; break; + case ECamSettingItemPhotoDigitalZoom: crKey = KCamCrPhotoExtDigZoom; break; + case ECamSettingItemImageRotation: crKey = KCamCrPhotoRotation; break; + case ECamSettingItemFlickerCancel: crKey = KCamCrFlickerCancellation; break; + + case ECamSettingItemImageToolbarItems: crKey = KCamCrImageToolbarItems; break; + case ECamSettingItemImageToolbarDefaultItems: crKey = KCamCrImageToolbarDefaultItems; break; + case ECamSettingItemContinuousAutofocus: crKey = KCamCrContinuousAutofocus; break; + default: CamPanic( ECamPanicUnknownSettingItem ); + break; + } + } + // ------------------------------------------------------- + // static video settings + else if( ECamSettingItemStaticVideoRangeMin < aSettingId + && ECamSettingItemStaticVideoRangeMax > aSettingId ) + { + PRINT( _L(" Camera <=> CCamStaticSettingsModel : ECamSettingItemStaticVideoRange") ); + switch( aSettingId ) + { + case ECamSettingItemVideoAudioRec: + if( aEmbedded ) crKey = KCamCrEmbeddedVideoAudRec; + else crKey = KCamCrVideoAudRec; + break; + case ECamSettingItemContinuousAutofocus: + crKey = KCamCrContinuousAutofocus; + break; + case ECamSettingItemVideoResolution: crKey = KCamCrVideoRes; break; + case ECamSettingItemVideoClipLength: crKey = KCamCrVideoClipLen; break; + case ECamSettingItemVideoFileType: crKey = KCamCrVideoFileType; break; + case ECamSettingItemVideoStoreInAlbum: crKey = KCamCrVideoStoreAlbum; break; //KCamCrDefaultAlbumId + case ECamSettingItemVideoShowCapturedVideo: crKey = KCamCrVideoShowCaptured; break; + case ECamSettingItemVideoMediaStorage: crKey = KCamCrVideoMemInUse; break; + case ECamSettingItemVideoNameBase: crKey = KCamCrVideoNameBase; break; + case ECamSettingItemVideoNameBaseType: crKey = KCamCrVideoNameType; break; + case ECamSettingItemVideoNumber: crKey = KCamCrVideoCount; break; + case ECamSettingItemVideoQuality: crKey = KCamCrVideoQuality; break; + case ECamSettingItemVideoDigitalZoom: crKey = KCamCrVideoExtDigZoom; break; + case ECamSettingItemVideoStab: crKey = KCamCrVideoStabilisation; break; + default: CamPanic( ECamPanicUnknownSettingItem ); + break; + } + } + // ------------------------------------------------------- + // static common settings + else if( ECamSettingItemStaticCommonRangeMin < aSettingId + && ECamSettingItemStaticCommonRangeMax > aSettingId ) + { + PRINT( _L("Camera <=> CCamStaticSettingsModel ECamSettingItemStaticCommon") ); + switch( aSettingId ) + { + case ECamSettingItemUserMode: crKey = KCamCrUserMode; break; + case ECamSettingItemDefaultAlbumId: crKey = KCamCrDefaultAlbumId; break; + case ECamSettingItemDefaultAlbumName: crKey = KCamCrDefaultAlbumTitle; break; + case ECamSettingItemRecLocation: crKey = KCamCrPhotoStoreLocation; break; + case ECamSettingItemPhotoEditorSupport: crKey = KCamCrPhotoEditorSupport; break; + case ECamSettingItemVideoEditorSupport: crKey = KCamCrVideoEditorSupport; break; + case ECamSettingItemRemovePhoneMemoryUsage: crKey = KCamCrRemovePhoneMemoryUsage; break; + case ECamSettingItemStopRecordingInHdmiMode: crKey = KCamCrStopRecordingInHdmiMode; break; + + default: CamPanic( ECamPanicUnknownSettingItem ); + break; + } + } + // ------------------------------------------------------- + else if( ECamSettingItemUserSceneRangeMin < aSettingId + && ECamSettingItemUserSceneRangeMax > aSettingId ) + { + PRINT( _L("Camera <=> CCamStaticSettingsModel ECamSettingItemUserSceneRange") ); + switch( aSettingId ) + { + case ECamSettingItemUserSceneBasedOnScene: crKey = KCamCrUserSceneBaseScene; break; + case ECamSettingItemUserSceneWhitebalance: crKey = KCamCrUserSceneWhiteBalance; break; + case ECamSettingItemUserSceneColourFilter: crKey = KCamCrUserSceneColourFilter; break; + case ECamSettingItemUserSceneExposure: crKey = KCamCrUserSceneExposure; break; + case ECamSettingItemUserSceneFlash: crKey = KCamCrUserSceneFlash; break; + case ECamSettingItemUserSceneBrightness: crKey = KCamCrUserSceneBrightness; break; + case ECamSettingItemUserSceneContrast: crKey = KCamCrUserSceneContrast; break; + case ECamSettingItemUserSceneImageSharpness: crKey = KCamCrUserSceneImageSharpness; break; + case ECamSettingItemUserSceneColourSaturation: crKey = KCamCrUserSceneColourSaturation; break; + case ECamSettingItemUserSceneLightSensitivity: crKey = KCamCrUserSceneLightSensitivity; break; + case ECamSettingItemUserSceneDefault: crKey = KCamCrUserSceneDefault; break; + default: CamPanic( ECamPanicUnknownSettingItem ); + break; + } + } + else + { + PRINT( _L(" Camera <=> CCamStaticSettingsModel CamPanic( ECamPanicUnknownSettingItem )") ); + CamPanic( ECamPanicUnknownSettingItem ); + } + + PRINT( _L("Camera <= CCamSettingsModel::MapSettingItem2CRKey") ); + return crKey; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +RPointerArray* +CCamStaticSettingsModel::MapSettingItem2SettingsList( TCamSettingItemIds aSettingId ) + { + PRINT( _L("Camera => CCamStaticSettingsModel::MapSettingItem2SettingsList") ); + + RPointerArray* array( NULL ); + + if( ECamSettingItemStaticPhotoRangeMin < aSettingId && + ECamSettingItemStaticPhotoRangeMax > aSettingId ) + { + if( ECamSettingItemPhotoNameBase == aSettingId ) + array = NULL; + else + array = &iStaticPhotoIntSettings; + } + else if( ECamSettingItemStaticVideoRangeMin < aSettingId && + ECamSettingItemStaticVideoRangeMax > aSettingId ) + { + if( ECamSettingItemVideoNameBase == aSettingId ) + array = NULL; + else + array = &iStaticVideoIntSettings; + } + else if( ECamSettingItemStaticCommonRangeMin < aSettingId && + ECamSettingItemStaticCommonRangeMax > aSettingId ) + { + array = &iStaticCommonIntSettings; + } + else + { + CamPanic( ECamPanicUnknownSettingItem ); + array = NULL; + } + + PRINT( _L("Camera <= CCamStaticSettingsModel::MapSettingItem2SettingsList") ); + return array; + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::~CCamStaticSettingsModel +// Destructor +// --------------------------------------------------------------------------- +// +CCamStaticSettingsModel::~CCamStaticSettingsModel() + { + PRINT( _L("Camera => ~CCamStaticSettingsModel") ); + iStaticCommonIntSettings.ResetAndDestroy(); + iStaticCommonIntSettings.Close(); + + iStaticPhotoIntSettings.ResetAndDestroy(); + iStaticPhotoIntSettings.Close(); + + iStaticVideoIntSettings.ResetAndDestroy(); + iStaticVideoIntSettings.Close(); + delete iRepository; + delete iConfigManager; + iConfigManager = NULL; + PRINT( _L("Camera <= ~CCamStaticSettingsModel") ); + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::CCamStaticSettingsModel +// C++ constructor +// --------------------------------------------------------------------------- +// +CCamStaticSettingsModel::CCamStaticSettingsModel( CCamConfiguration& aConfiguration ) + : iEmbedded( EFalse ), + iConfiguration( aConfiguration ) + { + iSecondaryCameraSettings.iVideoQuality + = iConfiguration.SecondaryCameraVideoQuality(); + iSecondaryCameraSettings.iPhotoQuality + = iConfiguration.SecondaryCameraImageQuality(); + + // Check that configuration can provide us secondary camera qualities + // If either of them is unavailable, all we can do is panic + PRINT( _L("Camera <> Checking secondary camera qualities") ); + __ASSERT_ALWAYS( iSecondaryCameraSettings.iVideoQuality > 0, + CamPanic( ECamPanicSecondaryQualityMissing ) ); + + __ASSERT_ALWAYS( iSecondaryCameraSettings.iPhotoQuality > 0, + CamPanic( ECamPanicSecondaryQualityMissing ) ); + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::ConstructL +// Symbian OS 2nd phase constructor +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::ConstructL() + { + PRINT( _L("Camera => CCamStaticSettingsModel::ConstructL") ); + iRepository = CRepository::NewL( KCRUidCameraappSettings ); + iConfigManager = CCameraUiConfigManager::NewL(); + PRINT( _L("Camera <= CCamStaticSettingsModel::ConstructL") ); + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SearchInSettingsListFor +// Searches in a settings list for a particular setting item. +// --------------------------------------------------------------------------- +// +TInt +CCamStaticSettingsModel::SearchInSettingsListFor( + const RPointerArray& aSettingsList, + TInt aSettingItem ) const + { + return aSettingsList.Find( aSettingItem, SettingIdMatches ); + } + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::ResetRepository +// Reset Camera central repository file +// --------------------------------------------------------------------------- +// + void CCamStaticSettingsModel::ResetRepository() + { + if( iRepository ) + { + iRepository->Reset(); + } + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::UnloadStaticSettings +// Remove any previously loaded static settings. +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::UnloadStaticSettings() + { + PRINT( _L("Camera => CCamStaticSettingsModel::UnloadStaticSettings()" )) + iStaticCommonIntSettings.ResetAndDestroy(); + iStaticPhotoIntSettings.ResetAndDestroy(); + iStaticVideoIntSettings.ResetAndDestroy(); + PRINT( _L("Camera <= CCamStaticSettingsModel::UnloadStaticSettings()" )) + } + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::LoadPhotoBaseNameL +// Loads the photo base name either from resource or from shared data +// as appropriate +// --------------------------------------------------------------------------- +// +void +CCamStaticSettingsModel::LoadPhotoBaseNameL() + { + User::LeaveIfError( iRepository->Get( KCamCrPhotoNameBase , iPhotoBaseName ) ); + // If photoname base not defined + if ( iPhotoBaseName.Length() == 0 ) + { + // Read base file name from resources and set the shared data key. + StringLoader::Load( iPhotoBaseName, R_CAM_NAMEBASE_IMAGE ); + } + } + +// +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::LoadVideoBaseNameL +// Loads the video base name either from resource or from shared data +// as appropriate +// --------------------------------------------------------------------------- +void +CCamStaticSettingsModel::LoadVideoBaseNameL() + { + User::LeaveIfError( iRepository->Get( KCamCrVideoNameBase , iVideoBaseName ) ); + if ( iVideoBaseName.Length() == 0 ) + { + // Read base file name from resources and set the shared data key. + StringLoader::Load( iVideoBaseName, R_CAM_NAMEBASE_VIDEO ); + } + } + + +// +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::LoadVideoBaseNameL +// Loads the video base name either from resource or from shared data +// as appropriate +// --------------------------------------------------------------------------- +void +CCamStaticSettingsModel::LoadDefaultAlbumNameL() + { + User::LeaveIfError( iRepository->Get( KCamCrDefaultAlbumTitle, + iDefaultAlbumName ) ); + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SavePhotoBaseNameL +// Saves the photo base name after comparing against resource to see if we +// have switched back to the default base +// --------------------------------------------------------------------------- +// +void +CCamStaticSettingsModel::SavePhotoBaseNameL() + { + TBuf savedBaseName; + TBuf resourceBaseName; + TBuf sharedDataBaseName = iPhotoBaseName; + + User::LeaveIfError( iRepository->Get( KCamCrPhotoNameBase, + savedBaseName ) ); + StringLoader::Load(resourceBaseName, R_CAM_NAMEBASE_IMAGE ); + + if ( savedBaseName.Length() == 0 && iPhotoBaseName == resourceBaseName ) + { + sharedDataBaseName = KNullDesC; + } + User::LeaveIfError( iRepository->Set( KCamCrPhotoNameBase, + sharedDataBaseName ) ); + } + +// +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SaveVideoBaseNameL +// Saves the video base name after comparing against resource to see if we +// have switched back to the default base +// --------------------------------------------------------------------------- +void CCamStaticSettingsModel::SaveVideoBaseNameL() + { + TBuf savedBaseName; + TBuf resourceBaseName; + TBuf sharedDataBaseName = iVideoBaseName; + + User::LeaveIfError( iRepository->Get( KCamCrVideoNameBase, + savedBaseName ) ); + StringLoader::Load(resourceBaseName, R_CAM_NAMEBASE_VIDEO ); + + if ( savedBaseName.Length() == 0 && + iVideoBaseName == resourceBaseName ) + { + sharedDataBaseName = KNullDesC; + } + + User::LeaveIfError( iRepository->Set( KCamCrVideoNameBase, + sharedDataBaseName ) ); + } + + +// +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::SaveDefaultAlbumNameL +// Saves the name of the default album set +// --------------------------------------------------------------------------- +void CCamStaticSettingsModel::SaveDefaultAlbumNameL() + { + User::LeaveIfError( iRepository->Set( KCamCrDefaultAlbumTitle, + iDefaultAlbumName ) ); + } + + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::ReadCenRepStringL +// --------------------------------------------------------------------------- +// +HBufC* +CCamStaticSettingsModel::ReadCenRepStringL( TInt aCenRepKeyId ) + { + PRINT1( _L("Camera => CCamSettingsModel::ReadCenRepStringL, key:0x%02x"), aCenRepKeyId ); + + HBufC* string = HBufC::NewLC( KCamCRStringInitialLength ); + + TPtr ptr = string->Des(); + TInt size = 0; + TInt status = iRepository->Get( aCenRepKeyId, ptr, size ); + + // Did not fit into the string, reserve more memory and try again + if( KErrOverflow == status ) + { + PRINT2( _L("Camera <> CCamSettingsModel: need bigger buffer, length: %d -> %d"), ptr.MaxLength(), size ); + CleanupStack::PopAndDestroy(); // String + string = HBufC::NewLC( size ); + ptr = string->Des(); + + status = iRepository->Get( aCenRepKeyId, ptr, size ); + } + + User::LeaveIfError( status ); + CleanupStack::Pop(); // string + PRINT1( _L("Camera <= CCamSettingsModel::ReadCenRepStringL, got string:[%S]"), string); + + return string; + } + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::ResetSettingItem +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::ResetSettingItem( const TInt aCenRepKeyId ) + { + TInt err = iRepository->Reset( aCenRepKeyId ); + if ( KErrNone != err ) + { + // Handle the error case + } + } + + +// --------------------------------------------------------------------------- +// CCamSettingsModel::StorePrimaryCameraSettingsL +// Stores the primary camera settings so they can be reapplied when +// changing from front to back camera +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::StorePrimaryCameraSettingsL() + { + PRINT( _L("Camera => CCamStaticSettingsModel::StorePrimaryCameraSettingsL")) + TInt settingIndex = SearchInSettingsListFor( iStaticPhotoIntSettings, + ECamSettingItemPhotoQuality ); + if ( settingIndex != KErrNotFound ) + { + iPrimaryCameraSettings.iPhotoQuality = + iStaticPhotoIntSettings[settingIndex]->iValueId; + } + + settingIndex = SearchInSettingsListFor( iStaticVideoIntSettings, + ECamSettingItemVideoQuality ); + if ( settingIndex != KErrNotFound ) + { + iPrimaryCameraSettings.iVideoQuality = + iStaticVideoIntSettings[settingIndex]->iValueId; + } + PRINT( _L("Camera <= CCamStaticSettingsModel::StorePrimaryCameraSettingsL")) + } + +// --------------------------------------------------------------------------- +// CCamSettingsModel::RestorePrimaryCameraSettingsL +// Restores the primary camera settings when +// changing from front to back camera +// --------------------------------------------------------------------------- +// +void CCamStaticSettingsModel::RestorePrimaryCameraSettingsL() + { + // set the stored primary camera settings + SetIntegerSettingValueL( ECamSettingItemPhotoQuality, + iPrimaryCameraSettings.iPhotoQuality ); + SetIntegerSettingValueL( ECamSettingItemVideoQuality, + iPrimaryCameraSettings.iVideoQuality ); + // set the secondary camera settings back to defaults + iSecondaryCameraSettings.iPhotoQuality = iConfiguration.SecondaryCameraImageQuality(); + iSecondaryCameraSettings.iVideoQuality = iConfiguration.SecondaryCameraVideoQuality(); + } + +#ifndef CAMERAAPP_PLUGIN_BUILD +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::LoadDynamicSettingsL +// Loads the dynamic settings from resource file for a +// particular group of settings. +// --------------------------------------------------------------------------- +// +void +CCamStaticSettingsModel::LoadSettingsFromResourceL( + TInt aResourceId, + RPointerArray& aSettingsList ) + { + // Create resource reader for reading photo static settings + TResourceReader reader; + CEikonEnv::Static()->CreateResourceReaderLC( reader, aResourceId ); + TInt count = reader.ReadInt16(); + + // for each entry in the resource, create a new setting item. + TInt i; + for ( i = 0; i < count; ++i ) + { + TIntSetting* newSetting = new (ELeave) TIntSetting; + CleanupStack::PushL( newSetting ); + + // Read the data for this setting item from resource. + newSetting->iItemId = reader.ReadInt16(); + newSetting->iValueId = reader.ReadInt16(); + + // Add the new setting item and its associated key + // to the parallel arrays for static photo settings. + aSettingsList.AppendL( newSetting ); + CleanupStack::Pop( newSetting ); + } + + CleanupStack::PopAndDestroy(); // reader + } +#endif //CAMERAAPP_PLUGIN_BUILD + +// --------------------------------------------------------------------------- +// CCamStaticSettingsModel::Configuration +// +// --------------------------------------------------------------------------- +// +CCamConfiguration& +CCamStaticSettingsModel::Configuration() const + { + return iConfiguration; + } + +// +// CCamStaticSettingsModel::LoadPhotoStaticSettingsL +// +void CCamStaticSettingsModel::LoadPhotoStaticSettingsL( const TBool aResetFromPlugin ) + { + if ( aResetFromPlugin ) + { + LoadCommonStaticSettingsL( aResetFromPlugin ); + iStaticPhotoIntSettings.ResetAndDestroy(); + } + // Load Photo/Image Settings + ReadFromCenRepL( static_cast( ECamSettingItemStaticPhotoRangeMin ), + static_cast( ECamSettingItemPhotoCompression ), + iStaticPhotoIntSettings ); + + } + +// +// CCamStaticSettingsModel::LoadVideoStaticSettingsL +// +void CCamStaticSettingsModel::LoadVideoStaticSettingsL( const TBool aResetFromPlugin ) + { + if ( aResetFromPlugin ) + { + LoadCommonStaticSettingsL( aResetFromPlugin ); + iStaticVideoIntSettings.ResetAndDestroy(); + } + // Load Video Settings + ReadFromCenRepL( static_cast( ECamSettingItemStaticVideoRangeMin ), + static_cast( ECamSettingItemVideoOpZoomOff ), + iStaticVideoIntSettings ); + + } + +// +// CCamStaticSettingsModel::LoadCommonStaticSettingsL +// +void CCamStaticSettingsModel::LoadCommonStaticSettingsL( const TBool aResetFromPlugin ) + { + if ( aResetFromPlugin ) + { + iStaticCommonIntSettings.ResetAndDestroy(); + } + // Load Common Settings + ReadFromCenRepL( static_cast( ECamSettingItemStaticCommonRangeMin ), + static_cast( ECamSettingItemStaticCommonRangeMax ), + iStaticCommonIntSettings ); + } + +/* + * Handle to Camera Ui Config Manager +*/ +CCameraUiConfigManager* CCamStaticSettingsModel::UiConfigManagerPtr() + { + return iConfigManager; + } +//End of File