/*

* 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() );

      // Both primary and secondary camera use Exif format

      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 =

        ( appUi->TargetMode() != ECamControllerIdle)

            ? appUi->TargetMode()

            : 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;