diff -r 000000000000 -r 1ddebce53859 camerauis/cameraapp/generic/src/cameracontroller/camsettingprovider.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/src/cameracontroller/camsettingprovider.cpp	Thu Jan 07 16:18:56 2010 +0200
@@ -0,0 +1,838 @@
+/*
+* 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:  Setting Provider class implementation
+*
+*/
+
+
+// ===========================================================================
+// Includes
+
+#include "camcameracontrollerflags.hrh"
+#include <ecam.h>
+#ifdef CAMERAAPP_CAPI_V2
+  #include <ecamadvsettings.h> // KECamFineResolutionFactor
+#endif
+
+#include <ECamOrientationCustomInterface2.h>
+
+#include "camlogging.h"
+#include "camcameracontroller.pan"
+#include "CamSettingsInternal.hrh"
+#include "camcameracontrollertypes.h"
+#include "camsettingprovider.h"
+#include "CamSettingsModel.h"
+#include "camsettingconversion.h"
+#include "CamAppController.h"
+#include "campointerutility.inl"
+#include "CameraUiConfigManager.h"
+
+#include "CamAppUi.h"
+#include "CamUtility.h"
+#include "CamPSI.h"
+
+#include "CamVideoQualityLevel.h"
+
+
+// ===========================================================================
+// Types
+
+using namespace NCamCameraController;
+
+#ifdef CAMERAAPP_CAPI_V2_ADV
+  typedef CCamera::CCameraAdvancedSettings CAS;
+#endif
+#ifdef CAMERAAPP_CAPI_V2_IP
+  typedef CCamera::CCameraImageProcessing  CIP;
+#endif
+
+// ===========================================================================
+// Local data
+
+static const TInt               KSettingArrayGranularity = 8;
+
+static const TSize              KViewfinderSize         = TSize(320, 240);
+static const TBool              KSnapshotMaintainAspect = EFalse;
+static const TInt               KEngineMultiplier       = 10;
+
+// ===========================================================================
+// Methods
+
+// static
+CCamSettingProvider*
+CCamSettingProvider::NewL( CCamAppController& aController,
+                           MCamSettingsModel* aSettingsModel )
+  {
+  CCamSettingProvider* self =
+      CCamSettingProvider::NewLC( aController, aSettingsModel );
+  CleanupStack::Pop( self );
+  return self;
+  }
+
+// static
+CCamSettingProvider*
+CCamSettingProvider::NewLC( CCamAppController& aController,
+                            MCamSettingsModel* aSettingsModel )
+  {
+  CCamSettingProvider* self =
+      new (ELeave) CCamSettingProvider( aController, aSettingsModel );
+  CleanupStack::PushL( self );
+  self->ConstructL();
+  return self;
+  }
+
+// virtual
+CCamSettingProvider::~CCamSettingProvider()
+  {
+  iPendingSettingChanges.Close();
+  }
+
+
+// ===========================================================================
+// From MCamSettingProvider
+
+// ---------------------------------------------------------------------------
+// virtual ProvideCameraParamL
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider::ProvideCameraParamL(
+    const NCamCameraController::TCamCameraParamId& aParamId,
+          TAny*                                      aParamData )
+  {
+  __ASSERT_DEBUG( aParamData, Panic( ECamNullPointer ) );
+  switch( aParamId )
+    {
+    // -----------------------------------------------------
+    case ECameraParamImage:
+      {
+      TPckgBuf<TCamParamsImage>* ptr =
+          static_cast<TPckgBuf<TCamParamsImage>*>( aParamData );
+      CheckNonNullL( ptr, KErrNotFound );
+      TCamParamsImage& params( (*ptr)() );
+      CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( CEikonEnv::Static()->AppUi() );
+      if ( appUi->ActiveCamera() == ECamActiveCameraSecondary )
+      	{
+      	params.iFormat = CCamera::EFormatJpeg;
+      	}
+      else // primary camera
+      	{
+      	params.iFormat = CCamera::EFormatExif;
+      	}
+      TCamPhotoSizeId PhotoSizeIndex = iSettingsModel->CurrentPhotoResolution();
+      TSize PhotoSize = iSettingsModel->ImageResolutionFromIndex( PhotoSizeIndex );
+      params.iSize     = PhotoSize;
+      params.iQualityFactor = iSettingsModel->CurrentPhotoCompression();
+      break;
+      }
+    // -----------------------------------------------------
+#ifdef CAMERAAPP_CAE_FOR_VIDEO
+    case ECameraParamVideoCae:
+      {
+      TPckgBuf<TCamParamsVideoCae>* ptr =
+          static_cast<TPckgBuf<TCamParamsVideoCae>*>( aParamData );
+      CheckNonNullL( ptr, KErrNotFound );
+
+      TCamParamsVideoCae& params( (*ptr)() );
+
+
+      TInt videoQuality = iSettingsModel->IntegerSettingValue( ECamSettingItemVideoQuality );
+
+      PRINT1( _L("Camera <> CCamSettingProvider::ProvideCameraParamL - video quality (index): %d"), videoQuality );
+      PRINT1( _L("Camera <> CCamSettingProvider::ProvideCameraParamL - quality count: %d"), iSettingsModel->VideoQualityArray().Count() );
+
+      CCamVideoQualityLevel& level = *( iSettingsModel->VideoQualityArray() )[videoQuality];
+      TInt res = level.VideoResolution();
+      PRINT1( _L("Camera <> CCamSettingProvider::ProvideCameraParamL - video resolution (index): %d"), res );
+      PRINT1( _L("Camera <> CCamSettingProvider::ProvideCameraParamL - resolution count: %d"), iSettingsModel->VideoResolutions().Count() );
+
+      // Video resolutions array in Setting Model is set up from
+      // R_CAM_VIDEO_RESOLUTION_ARRAY resource. New resolutions
+      // need to be added there also, in addition to configuration files.
+      TSize resolution =  ( iSettingsModel->VideoResolutions() )[ res ];
+      params.iFrameSize    = resolution;
+      params.iFrameRate    = level.FrameRate();
+      params.iVideoBitRate = level.VideoBitRate();
+      params.iAudioBitRate = level.AudioBitRate();
+      params.iAudioOn      = iSettingsModel->IntegerSettingValue( ECamSettingItemVideoAudioRec );
+      params.iMimeType.Set ( level.VideoMimeType() );
+      params.iSupplier.Set ( level.PreferredSupplier() );
+      params.iVideoType.Set( level.VideoFileType() );
+      params.iAudioType.Set( level.AudioType() );
+
+      TInt framerate = -1;
+      TCamSceneId videoscene = static_cast< TCamSceneId > (
+              iSettingsModel->IntegerSettingValue(ECamSettingItemDynamicVideoScene) );
+
+      framerate = iSettingsModel->SceneSettingValue(videoscene, ECamSettingItemSceneFramerate);
+
+      // Change the framerate if scene has defined it to be > 0
+      if ( framerate > 0 )
+          {
+          params.iFrameRate = framerate;
+          }
+
+      PRINT1( _L("Camera <> CCamSettingProvider::ProvideCameraParamL ECameraParamVideoCae framerate: %d"), framerate )
+
+      break;
+      }
+#endif // CAMERAAPP_CAE_FOR_VIDEO
+    // -----------------------------------------------------
+    case ECameraParamVfMode:
+      {
+      CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );
+      TPckgBuf<TCamViewfinderMode>* ptr =
+          static_cast<TPckgBuf<TCamViewfinderMode>*>( aParamData );
+      CheckNonNullL( ptr, KErrNotFound );
+      TCamViewfinderMode& params( (*ptr)() );
+      TBool isPrimaryCamera = appUi->ActiveCamera() == ECamActiveCameraPrimary;
+
+      if ( iController.IsDirectScreenVFSupported( isPrimaryCamera ) )
+        {// primary camera or 2nd camera DSVF
+        PRINT( _L("Setting Provider <> provide ECameraParamVfMode == ECamViewfinderDirect") );
+        params = ECamViewfinderDirect;
+        }
+      else
+        {// primary camera or 2nd camera bitmap view finder
+        PRINT( _L("Setting Provider <> provide ECameraParamVfMode == ECamViewfinderBitmap") );
+        params = ECamViewfinderBitmap;
+        }
+      break;
+      }
+    // -----------------------------------------------------
+    case ECameraParamVfBitmap:
+        {
+        CCamAppUi* appUi = static_cast<CCamAppUi*>(
+            CEikonEnv::Static()->AppUi() );
+        PRINT2( _L("Setting Provider <> provide ECameraParamVfBitmap. CurrentMode: (%d) TargetMode: (%d)"), iController.CurrentMode(), appUi->TargetMode() );
+        TPckgBuf<TCamParamsVfBitmap>* ptr =
+          static_cast<TPckgBuf<TCamParamsVfBitmap>*>( aParamData );
+        CheckNonNullL( ptr, KErrNotFound );
+        TCamParamsVfBitmap& params( (*ptr)() );
+
+        TDisplayMode displayMode =
+            CEikonEnv::Static()->ScreenDevice()->DisplayMode();
+        CCamera::TFormat viewfinderFormat =
+            CCamSettingConversion::Map2CameraFormat( displayMode );
+
+        const TCamCameraMode cameraMode = iController.CurrentMode();
+        const TInt           resolution = (cameraMode == ECamControllerVideo)
+                                        ? iController.GetCurrentVideoResolution()
+                                        : iController.GetCurrentImageResolution();
+        params.iRect   = CamUtility::ViewfinderLayout( cameraMode, resolution );
+
+        params.iFormat = viewfinderFormat;
+
+        // Mirror viewfinder for secondary camera
+        params.iMirrorImage = ECamActiveCameraSecondary == appUi->ActiveCamera();
+
+        break;
+        }
+    // -----------------------------------------------------
+    case ECameraParamVfDirect:
+      {
+      // Not supported yet.
+      User::Leave( KErrNotSupported );
+      break;
+      }
+    // -----------------------------------------------------
+    case ECameraParamSnapshot:
+      {
+      TPckgBuf<TCamParamsSnapshot>* ptr =
+          static_cast<TPckgBuf<TCamParamsSnapshot>*>( aParamData );
+      CheckNonNullL( ptr, KErrNotFound );
+      TCamParamsSnapshot& params( (*ptr)() );
+
+      // Fetch the snapshot size
+      TDisplayMode   displayMode = CEikonEnv::Static()->ScreenDevice()->DisplayMode();
+      TCamCameraMode cameraMode  = iController.CurrentMode();
+      TInt           resolution  = (cameraMode == ECamControllerVideo)
+                                      ? iController.GetCurrentVideoResolution()
+                                      : iController.GetCurrentImageResolution();
+      params.iSize           = CamUtility::ViewfinderLayout( cameraMode, resolution ).Size();
+      params.iFormat         = CCamSettingConversion::Map2CameraFormat(displayMode);
+      params.iMaintainAspect = KSnapshotMaintainAspect;
+      break;
+      }
+    // -----------------------------------------------------
+    default:
+      {
+      User::Leave( KErrNotSupported );
+      break;
+      }
+    // -----------------------------------------------------
+    }
+  }
+
+
+// ---------------------------------------------------------------------------
+// virtual ProvideCameraSettingL
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider::ProvideCameraSettingL(
+    const NCamCameraController::TCamCameraSettingId& aSettingId,
+          TAny*                                      aSettingData )
+  {
+  CheckNonNullL( aSettingData, KErrArgument );
+
+  TCamCameraMode mode( iController.CurrentMode() );
+
+  switch( aSettingId )
+    {
+    // -----------------------------------------------------
+    // Flash
+    case ECameraSettingFlash:
+    case ECameraUserSceneSettingFlash:
+      {
+      TCamFlashId flashId = static_cast<TCamFlashId> (iSettingsModel->
+                     IntegerSettingValue( ECamSettingItemDynamicPhotoFlash ) );
+      if ( mode == ECamControllerVideo )
+        {
+        flashId = static_cast<TCamFlashId> (iSettingsModel->
+                     IntegerSettingValue( ECamSettingItemDynamicVideoFlash ) );
+        }
+      CCamera::TFlash CamFlashId = CCamSettingConversion::Map2CameraFlash( flashId );
+      CCamera::TFlash* ptr = static_cast<CCamera::TFlash*>( aSettingData );
+      *ptr = CamFlashId;
+      break;
+      }
+    // -----------------------------------------------------
+    // Exposure (EV mode + EV compensation step)
+    case ECameraSettingExposure:
+    case ECameraUserSceneSettingExposure:
+      {
+      TPckgBuf<TCamSettingDataExposure>* ptr =
+        static_cast<TPckgBuf<TCamSettingDataExposure>*>( aSettingData );
+      TCamSettingDataExposure& evData( (*ptr)() );
+
+      TInt sceneItemId = ( ECamControllerVideo == mode )
+                         ? ECamSettingItemDynamicVideoScene
+                         : ECamSettingItemDynamicPhotoScene;
+
+      TInt sceneId = iSettingsModel->IntegerSettingValue( sceneItemId );
+
+      TCamSceneAEMode evMode =
+        static_cast<TCamSceneAEMode>(
+          iSettingsModel->SceneSettingValue( sceneId, ECamSettingItemSceneAEMode ) );
+
+      evData.iExposureMode = CCamSettingConversion::Map2CameraExposureMode( evMode );
+      PRINT1( _L("Camera <> provide EV mode: %016b"), evData.iExposureMode );
+#ifdef CAMERAAPP_CAPI_V2
+      TInt evKey;
+      if ( ECameraUserSceneSettingExposure != aSettingId )
+        {
+        evKey   = ( ECamControllerVideo == mode )
+                   ? ECamSettingItemDynamicVideoExposure
+                   : ECamSettingItemDynamicPhotoExposure;
+        }
+      else
+        {
+        evKey   = ECamSettingItemUserSceneExposure;
+        }
+
+      TInt evValue = iSettingsModel->IntegerSettingValue( evKey );
+      if( iEvStepAsUiValue != 0 )
+        evData.iExposureStep = (evValue * KECamFineResolutionFactor) / iEvStepAsUiValue;
+      else
+        evData.iExposureStep = 0;
+      PRINT1( _L("Camera <> provide EV compensation: %d"), evData.iExposureStep );
+#else
+      evData.iExposureStep = 0;
+#endif
+      break;
+      }
+    // -----------------------------------------------------
+    // Light sensitivity (ISO value)
+    case ECameraSettingLightSensitivity:
+    case ECameraUserSceneSettingLightSensitivity:
+      {
+      TInt* ptr = static_cast<TInt*>( aSettingData );
+      TInt isoKey;
+
+      if ( ECameraUserSceneSettingLightSensitivity != aSettingId )
+        {
+        isoKey   =  ( ECamControllerVideo == mode )
+                    ? ECamSettingItemDynamicVideoLightSensitivity
+                    : ECamSettingItemDynamicPhotoLightSensitivity;
+        }
+      else
+        {
+        isoKey = ECamSettingItemUserSceneLightSensitivity;
+        }
+      // TCamLightSensitivityId type value returned
+      TCamLightSensitivityId isoId =
+        static_cast<TCamLightSensitivityId>( iSettingsModel->IntegerSettingValue( isoKey ) );
+
+      *ptr = CamUtility::MapLightSensitivity2IsoValueL( isoId, iSupportedISORates );
+      PRINT1( _L("Camera <> provide ISO rate: %d"), *ptr );
+      break;
+      }
+    // -----------------------------------------------------
+    // White balance
+    case ECameraSettingWhiteBalance:
+    case ECameraUserSceneSettingWhiteBalance:
+      {
+      TPckgBuf<TCamSettingDataWhiteBalance>* ptr =
+        static_cast<TPckgBuf<TCamSettingDataWhiteBalance>*>( aSettingData );
+      TInt key;
+
+      if ( ECameraUserSceneSettingWhiteBalance != aSettingId )
+        {
+        key = ( ECamControllerVideo == mode )
+               ? ECamSettingItemDynamicVideoWhiteBalance
+               : ECamSettingItemDynamicPhotoWhiteBalance;
+        }
+      else
+        {
+        key = ECamSettingItemUserSceneWhitebalance;
+        }
+
+      TCamSettingDataWhiteBalance& wbData( (*ptr)() );
+
+      TCamWhiteBalanceId WB = static_cast<TCamWhiteBalanceId>(iSettingsModel->IntegerSettingValue( key ));
+      CCamera::TWhiteBalance CamWB = CCamSettingConversion::Map2CameraWb( WB );
+
+      wbData.iWhiteBalanceMode = CamWB;
+      break;
+      }
+#ifdef CAMERAAPP_CAPI_V2_IP
+    // -----------------------------------------------------
+    // Colour effect (colour filter: sepia/b&w/vivid/..)
+    case ECameraSettingColourEffect:
+    case ECameraUserSceneSettingColourEffect:
+      {
+      CIP::TEffect* ptr = static_cast<CIP::TEffect*>( aSettingData );
+
+      TInt key;
+
+      if ( ECameraUserSceneSettingColourEffect != aSettingId )
+        {
+        key = ( ECamControllerVideo == mode )
+               ? ECamSettingItemDynamicVideoColourFilter
+               : ECamSettingItemDynamicPhotoColourFilter;
+        }
+      else
+        {
+        key = ECamSettingItemUserSceneColourFilter;
+        }
+
+      TCamColourFilterId uiValue =
+        static_cast<TCamColourFilterId>( iSettingsModel->IntegerSettingValue( key ) );
+
+      CIP::TEffect effect = CCamSettingConversion::Map2CameraEffect( uiValue );
+
+      PRINT1( _L("Camera <> provide colour effect: 0x%08x"), effect );
+      *ptr = effect;
+      break;
+      }
+    // -----------------------------------------------------
+    // Sharpness
+    case ECameraSettingSharpness:
+    case ECameraUserSceneSettingSharpness:
+      {
+      TInt* ptr = static_cast<TInt*>( aSettingData );
+
+      TInt key;
+
+      if ( ECameraUserSceneSettingSharpness != aSettingId )
+        {
+        key = ECamSettingItemDynamicPhotoImageSharpness;
+        }
+      else
+        {
+        key = ECamSettingItemUserSceneImageSharpness;
+        }
+      TCamImageSharpnessId uiValue =
+        static_cast<TCamImageSharpnessId>(
+          iSettingsModel->IntegerSettingValue( key ) );
+
+      TInt sharpness = CamUtility::MapSharpnessId2SharpnessValueL( uiValue );
+      PRINT1( _L("Camera <> provide sharpness: %d"), sharpness );
+      *ptr = sharpness;
+
+      break;
+      }
+#endif // CAMERAAPP_CAPI_V2_IP
+    // -----------------------------------------------------
+    // Brightness
+    case ECameraSettingBrightness:
+    case ECameraUserSceneSettingBrightness:
+      {
+      CCamera::TBrightness* ptr =
+          static_cast<CCamera::TBrightness*>( aSettingData );
+
+      TInt key;
+
+      if ( ECameraUserSceneSettingBrightness != aSettingId )
+        {
+        key = ( ECamControllerVideo == mode )
+               ? ECamSettingItemDynamicVideoBrightness
+               : ECamSettingItemDynamicPhotoBrightness;
+        }
+      else
+        {
+        key = ECamSettingItemUserSceneBrightness;
+        }
+
+      TInt SettingsBrightness = iSettingsModel->IntegerSettingValue( key );
+      CCamera::TBrightness CamBrightness = CCamera::TBrightness( KEngineMultiplier * SettingsBrightness );
+
+      PRINT1( _L("Camera <> provide brightness: %d"), CamBrightness );
+      *ptr = CamBrightness;
+      break;
+      }
+    // -----------------------------------------------------
+    // Contrast
+    case ECameraSettingContrast:
+    case ECameraUserSceneSettingContrast:
+      {
+      CCamera::TContrast* ptr = static_cast<CCamera::TContrast*>( aSettingData );
+      TInt key;
+
+      if ( ECameraUserSceneSettingContrast != aSettingId )
+        {
+        key = ( ECamControllerVideo == mode )
+               ? ECamSettingItemDynamicVideoContrast
+               : ECamSettingItemDynamicPhotoContrast;
+        }
+      else
+        {
+        key = ECamSettingItemUserSceneContrast;
+        }
+
+      TInt SettingsContrast = iSettingsModel->IntegerSettingValue( key );
+      CCamera::TContrast CamContrast = CCamera::TContrast( KEngineMultiplier * SettingsContrast );
+      PRINT1( _L("Camera <> provide contrast: %d"), CamContrast );
+      *ptr = CamContrast;
+      break;
+      }
+    // -----------------------------------------------------
+    // Digital zoom
+    case ECameraSettingDigitalZoom:
+      {
+      TInt* ptr = static_cast<TInt*>( aSettingData );
+      CheckNonNullL( ptr, KErrArgument );
+      *ptr = iController.ZoomValue();
+      break;
+      }
+    // -----------------------------------------------------
+    // Optical zoom
+    case ECameraSettingOpticalZoom:
+      {
+      User::Leave( KErrNotSupported );
+      //iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoOpticalZoom );
+      break;
+      }
+#ifdef CAMERAAPP_CAPI_V2_ADV
+    case ECameraSettingFocusRange:
+      {
+      // User::Leave( KErrNotSupported );
+      CAS::TFocusRange* ptr = static_cast<CAS::TFocusRange*>( aSettingData );
+
+      // Get current scene, from which the focus range value should be obtained
+      TInt currentScene = iSettingsModel->IntegerSettingValue( ECamSettingItemDynamicPhotoScene );
+      if ( currentScene  == ECamSceneUser )
+        {
+        // In case of user scene, use the base scene instead
+        currentScene = iSettingsModel->IntegerSettingValue( ECamSettingItemUserSceneBasedOnScene );
+        }
+      PRINT1( _L("Camera <> current scene: %d"), currentScene );
+
+      // Get the autofocus mode in camera internal format
+      TInt afMode = iSettingsModel->SceneSettingValue( currentScene, ECamSettingItemSceneAFMode );
+
+      PRINT1( _L("Camera <> Autofocusmode for current scene: %d"), afMode );
+
+      TCamSettingsOnOff facetrack =
+      static_cast<TCamSettingsOnOff>(
+          iSettingsModel->IntegerSettingValue( ECamSettingItemFaceTracking ) );
+      if ( iController.UiConfigManagerPtr() && iController.UiConfigManagerPtr()->IsFaceTrackingSupported() &&
+           ( ECamSettOn == facetrack ) )
+          {
+          // Use CCamera::CCameraAdvancedSettings::EFocusRangeAuto if in facetracking mode.
+          *ptr = CCamera::CCameraAdvancedSettings::EFocusRangeAuto;
+          }
+      else
+          {
+          // Convert it to TFocusRange
+          *ptr = CCamSettingConversion::Map2CameraAutofocus( static_cast<TCamSceneAFMode>( afMode ) );
+          PRINT1( _L("Camera <> Autofocusmode mapped for CCamera: %d"), *ptr );
+          }
+      //CheckNonNullL( ptr, KErrNotFound );
+      //*ptr = KFocusRange;//iSettingsModel->IntegerSettingValue( ECamSettingItemDynamicPhotoFocusRange );
+      break;
+      }
+    // -----------------------------------------------------
+    case ECameraSettingCaptureLimit:
+      {
+      TInt* ptr = static_cast<TInt*>( aSettingData );
+      *ptr = iController.CaptureLimitSetting();
+
+      PRINT1( _L("Camera <> provide capture limit: %d"), *ptr );
+      break;
+      }
+    // -----------------------------------------------------
+    // Stabilization setting (for video)
+    case ECameraSettingStabilization:
+      {
+      TCamSettingDataStabilization& stabilization =
+        ( *static_cast<TPckgBuf<TCamSettingDataStabilization>*>( aSettingData ) )();
+
+      TCamSettingsOnOff settingOn =
+        static_cast<TCamSettingsOnOff>( iSettingsModel->IntegerSettingValue( ECamSettingItemVideoStab ) );
+
+      // These could be made product specific..
+      if( ECamSettOn == settingOn )
+        {
+        PRINT( _L("Camera <> Stabilization is set ON") );
+        stabilization.iMode       = CAS::EStabilizationModeAuto;
+        stabilization.iEffect     = CAS::EStabilizationAuto;
+        stabilization.iComplexity = CAS::EStabilizationComplexityAuto;
+        }
+      else
+        {
+        PRINT( _L("Camera <> Stabilization is set OFF") );
+        stabilization.iMode       = CAS::EStabilizationModeOff;
+        stabilization.iEffect     = CAS::EStabilizationOff;
+        stabilization.iComplexity = CAS::EStabilizationComplexityAuto;
+        }
+      break;
+      }
+#endif // CAMERAAPP_CAPI_V2_ADV
+    // -----------------------------------------------------
+    // Device orientation setting
+    case ECameraSettingOrientation:
+      {
+      MCameraOrientation::TOrientation* ptr =
+        static_cast<MCameraOrientation::TOrientation*>( aSettingData );
+
+      TCamImageOrientation orientationSetting =
+        static_cast<TCamImageOrientation>( iController.ImageOrientation() );
+      PRINT1( _L("Camera <> Got image orientation from ui: [%s]"), KCamOrientationNames[orientationSetting] );
+
+      *ptr = CCamSettingConversion::Map2CameraOrientation( orientationSetting );
+      PRINT1( _L("Camera <> provide camera orientation: 0x%02X"), *ptr );
+      break;
+      }
+    // -----------------------------------------------------
+    // Video audio mute setting
+    case ECameraSettingAudioMute:
+      {
+      TCamSettingsOnOff mute =
+        static_cast<TCamSettingsOnOff>(
+          iSettingsModel->IntegerSettingValue( ECamSettingItemVideoAudioRec ) );
+
+      TBool* ptr = static_cast<TBool*>( aSettingData );
+      *ptr = (ECamSettOn == mute);
+      PRINT1( _L("Camera <> provide mute on: %d"), *ptr );
+      break;
+      }
+    // -----------------------------------------------------
+    // Continuous autofocus setting
+    case ECameraSettingContAF: 
+      {
+      TCamSettingsOnOff caf = static_cast<TCamSettingsOnOff>( 
+         iSettingsModel->IntegerSettingValue( ECamSettingItemContinuousAutofocus ) );
+
+      TBool* ptr = static_cast<TBool*>( aSettingData );
+      *ptr = (ECamSettOn == caf);
+      PRINT1( _L("Camera <> provide continuous autofocus on: %d"), *ptr );      
+      break;
+      }
+    // -----------------------------------------------------
+    // facetracking setting
+    case ECameraSettingFacetracking:
+      {
+      TCamSettingsOnOff facetrack =
+        static_cast<TCamSettingsOnOff>(
+          iSettingsModel->IntegerSettingValue( ECamSettingItemFaceTracking ) );
+      TBool* ptr = static_cast<TBool*>( aSettingData );
+      *ptr = (ECamSettOn == facetrack);
+      PRINT1( _L("Camera <> provide facetracking on: %d"), *ptr );
+      break;
+      }
+    // -----------------------------------------------------
+    // Video max size in bytes
+    case ECameraSettingFileMaxSize:
+      {
+      TCamVideoClipLength setting =
+        static_cast<TCamVideoClipLength>(
+          iSettingsModel->IntegerSettingValue( ECamSettingItemVideoClipLength ) );
+
+      TInt* ptr = static_cast<TInt*>( aSettingData );
+
+      *ptr = ( ECamVideoClipShort == setting )
+             ? CamUtility::MaxMmsSizeInBytesL()
+             : 0; // 0 means not limited
+
+      PRINT1( _L("Camera <> provide max file size: %d"), *ptr );
+      break;
+      }
+    // -----------------------------------------------------
+    // Video filename
+    case ECameraSettingFileName:
+      {
+      TPtr* ptr = static_cast<TPtr*>( aSettingData );
+      //*ptr = iController.CurrentFullFileName();
+      *ptr = iController.CurrentVideoFileName();
+      break;
+      }
+    // -----------------------------------------------------
+    default:
+      {
+#ifndef CAMERAAPP_EMULATOR_BUILD
+      User::Leave( KErrNotSupported );
+#endif // not CAMERAAPP_EMULATOR_BUILD
+      break;
+      }
+    // -----------------------------------------------------
+    }
+  }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider::ProvidePendingSettingChangesL(
+    RArray<NCamCameraController::TCamCameraSettingId>& aSettingIds )
+  {
+  PRINT( _L("Camera => CCamSettingProvider::ProvidePendingSettingChangesL") );
+  aSettingIds.Reset();
+  aSettingIds.ReserveL( iPendingSettingChanges.Count() );
+  for( TInt i = 0; i < iPendingSettingChanges.Count(); i++ )
+    {
+    aSettingIds.AppendL( iPendingSettingChanges[i] );
+    }
+  PRINT1( _L("Camera <> %d settings changed"), aSettingIds.Count() );
+
+  // These have been asked and delivered now.
+  // Update: Reset only when asked. Enables retries.
+  // iPendingSettingChanges.Reset();
+  PRINT( _L("Camera <= CCamSettingProvider::ProvidePendingSettingChangesL") );
+  }
+
+
+// ---------------------------------------------------------------------------
+// PendingSettingChangeCount
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamSettingProvider::PendingSettingChangeCount() const
+  {
+  return iPendingSettingChanges.Count();
+  }
+
+
+// ===========================================================================
+// New methods
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider::Reset()
+  {
+  PRINT( _L("Camera =><= CCamSettingProvider::Reset") );
+  iPendingSettingChanges.Reset();
+  }
+
+// ---------------------------------------------------------------------------
+// AddPendingSettingChangesL
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider
+::AddPendingSettingChangesL( const RArray<TCamSettingItemIds>& aUiSettingIds )
+  {
+  iPendingSettingChanges.ReserveL( aUiSettingIds.Count()
+                                 + iPendingSettingChanges.Count() );
+
+  for( TInt i = 0; i < aUiSettingIds.Count(); i++ )
+    {
+    AddPendingSettingChangeL( aUiSettingIds[i] );
+    }
+  }
+
+// ---------------------------------------------------------------------------
+// AddPendingSettingChangeL
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider
+::AddPendingSettingChangeL( TCamSettingItemIds aUiSettingId )
+  {
+  PRINT1( _L("Camera => CCamSettingProvider::AddPendingSettingChangeL [%s]"),
+          KCamSettingItemNames[aUiSettingId] );
+
+  TCamCameraSettingId cameraId =
+      CCamSettingConversion::Map2CameraControllerSettingId( aUiSettingId );
+
+  if( ECameraSettingNone != cameraId )
+    {
+    // Add each setting only once
+    if( KErrNotFound == iPendingSettingChanges.Find( cameraId ) )
+      {
+      PRINT1( _L("Camera <> Add pending setting [%s]"), KCameraSettingNames[cameraId] );
+      iPendingSettingChanges.AppendL( cameraId );
+      }
+    }
+  else
+    {
+    User::Leave( KErrNotSupported );
+    }
+  PRINT( _L("Camera <= CCamSettingProvider::AddPendingSettingChangeL") );
+  }
+
+// ---------------------------------------------------------------------------
+// SetSupportedISORatesL
+//
+// ---------------------------------------------------------------------------
+//
+void
+CCamSettingProvider::SetSupportedISORatesL( const RArray<TInt>& aSupportedIsoRates )
+  {
+  iSupportedISORates = aSupportedIsoRates;
+  if ( iSupportedISORates.Count() != 0 )
+    {
+    iValidISORates = ETrue;
+    }
+  }
+
+// ===========================================================================
+// private
+
+void
+CCamSettingProvider::ConstructL()
+  {
+  PRINT( _L("Camera => CCamSettingProvider::ConstructL") );
+  // Get EV steps range.
+  iEvStepAsUiValue = iController.EvRange().iStepsPerUnit;
+  PRINT( _L("Camera <= CCamSettingProvider::ConstructL") );
+  }
+
+
+CCamSettingProvider::CCamSettingProvider( CCamAppController& aController,
+                                          MCamSettingsModel* aSettingsModel )
+ : iSettingsModel( aSettingsModel ),
+   iController   ( aController    ),
+   iPendingSettingChanges( KSettingArrayGranularity )
+  {
+  }
+
+