/*
* 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 <StringLoader.h>
#include <barsread.h>
#include <AknQueryDialog.h>
#include <ecam.h>
#ifndef CAMERAAPP_PLUGIN_BUILD
#include <cameraapp.rsg>
#include <vgacamsettings.rsg>
#include "camsettingconversion.h"
#else
#include <gscamerapluginrsc.rsg>
#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;
// If setting item is in the static photo settings return it's value.
if( ECamSettingItemStaticPhotoRangeMax > aSettingItem
&& ECamSettingItemStaticPhotoRangeMin < aSettingItem )
{
TInt settingIndex = SearchInSettingsListFor(
iStaticPhotoIntSettings,
aSettingItem );
value = iStaticPhotoIntSettings[settingIndex]->iValueId;
}
// Otherwise, if setting item is in the static video settings return it's value.
else if( ECamSettingItemStaticVideoRangeMax > aSettingItem
&& ECamSettingItemStaticVideoRangeMin < aSettingItem )
{
TInt settingIndex = SearchInSettingsListFor( iStaticVideoIntSettings, aSettingItem );
value = iStaticVideoIntSettings[settingIndex]->iValueId;
}
// Look in static common settings.
else if( ECamSettingItemStaticCommonRangeMax > aSettingItem
&& ECamSettingItemStaticCommonRangeMin < aSettingItem )
{
TInt settingIndex = SearchInSettingsListFor( iStaticCommonIntSettings, aSettingItem );
value = iStaticCommonIntSettings[settingIndex]->iValueId;
}
else
{
PRINT( _L("Camera <> Not found, PANIC !! ECamPanicUnknownSettingItem" ))
CamPanic( ECamPanicUnknownSettingItem );
}
return value;
}
// ---------------------------------------------------------------------------
// CCamStaticSettingsModel::SetIntegerSettingValueL
// Sets a new integer value for the specified setting
// ---------------------------------------------------------------------------
//
void
CCamStaticSettingsModel::SetIntegerSettingValueL( TInt aSettingItem,
TInt aSettingValue )
{
TCamSettingItemIds settingId(
static_cast<TCamSettingItemIds>(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<TCamSettingItemIds>(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 <TIntSetting>& 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<TCamSettingItemIds>( i ),
iEmbedded );
ReadCenRepIntL( static_cast<TCamSettingItemIds>( 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<CCamAppUiBase*>(
CEikonEnv::Static()->AppUi() )->ActiveCamera() == ECamActiveCameraSecondary )
{
PRINT(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL Setting secondary camera image quality" ))
newSetting->iValueId = iConfiguration.SecondaryCameraImageQuality();
}
else
{
appUi = static_cast<CCamAppUiBase*>( 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<CCamAppUiBase*>(
CEikonEnv::Static()->AppUi() )->ActiveCamera() == ECamActiveCameraSecondary )
{
PRINT(_L("Camera <=> CCamStaticSettingsModel::LoadEmbeddedSettingsL Setting secondary camera image quality" ))
newSetting->iValueId = iConfiguration.SecondaryCameraVideoQuality();
}
else
{
appUi = static_cast<CCamAppUiBase*>( 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 <TIntSetting>& 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<CCamAppUiBase*>(
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<TIntSetting>& 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<CCamAppUiBase*>( 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<CCamAppUiBase*>( 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<TIntSetting>* settingArray =
MapSettingItem2SettingsList( aSettingId );
if( settingArray )
{
TUint32 crKey = MapSettingItem2CRKey( aSettingId, iEmbedded );
SaveCenRepItemL( aSettingId, crKey, *settingArray );
}
else
{
CamPanic( ECamPanicUnknownSettingItem );
}
break;
}
} // switch
PRINT( _L("CCamStaticSettingsModel <= SaveStaticSettingL") );
}
// ---------------------------------------------------------------------------
// MapSettingItem2CRKey <<static>>
// ---------------------------------------------------------------------------
//
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;
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;
default: CamPanic( ECamPanicUnknownSettingItem );
break;
}
}
else
{
PRINT( _L(" Camera <=> CCamStaticSettingsModel CamPanic( ECamPanicUnknownSettingItem )") );
CamPanic( ECamPanicUnknownSettingItem );
}
PRINT( _L("Camera <= CCamSettingsModel::MapSettingItem2CRKey") );
return crKey;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
RPointerArray<TIntSetting>*
CCamStaticSettingsModel::MapSettingItem2SettingsList( TCamSettingItemIds aSettingId )
{
PRINT( _L("Camera => CCamStaticSettingsModel::MapSettingItem2SettingsList") );
RPointerArray<TIntSetting>* 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<TIntSetting>& 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<KMaxNameBaseLength> savedBaseName;
TBuf<KMaxNameBaseLength> resourceBaseName;
TBuf<KMaxNameBaseLength> 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<KMaxNameBaseLength> savedBaseName;
TBuf<KMaxNameBaseLength> resourceBaseName;
TBuf<KMaxNameBaseLength> 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<TIntSetting>& 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<TInt>( ECamSettingItemStaticPhotoRangeMin ),
static_cast<TInt>( ECamSettingItemPhotoCompression ),
iStaticPhotoIntSettings );
}
//
// CCamStaticSettingsModel::LoadVideoStaticSettingsL
//
void CCamStaticSettingsModel::LoadVideoStaticSettingsL( const TBool aResetFromPlugin )
{
if ( aResetFromPlugin )
{
LoadCommonStaticSettingsL( aResetFromPlugin );
iStaticVideoIntSettings.ResetAndDestroy();
}
// Load Video Settings
ReadFromCenRepL( static_cast<TInt>( ECamSettingItemStaticVideoRangeMin ),
static_cast<TInt>( ECamSettingItemVideoOpZoomOff ),
iStaticVideoIntSettings );
}
//
// CCamStaticSettingsModel::LoadCommonStaticSettingsL
//
void CCamStaticSettingsModel::LoadCommonStaticSettingsL( const TBool aResetFromPlugin )
{
if ( aResetFromPlugin )
{
iStaticCommonIntSettings.ResetAndDestroy();
}
// Load Common Settings
ReadFromCenRepL( static_cast<TInt>( ECamSettingItemStaticCommonRangeMin ),
static_cast<TInt>( ECamSettingItemStaticCommonRangeMax ),
iStaticCommonIntSettings );
}
/*
* Handle to Camera Ui Config Manager
*/
CCameraUiConfigManager* CCamStaticSettingsModel::UiConfigManagerPtr()
{
return iConfigManager;
}
//End of File