/*

* 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:  Manages all settings data.*

*/

// ===========================================================================

// Includes

#include <StringLoader.h>

#include <barsread.h>

#include <AknQueryDialog.h>

#include <ecam.h>

#include <data_caging_path_literals.hrh>  // KDC_APP_RESOURCE_DIR

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamSettingsModel.h"

#include "CamPanic.h"

#include "mcamsettingsmodelobserver.h"

#include "CamAppUiBase.h"

#include "CamSharedDataKeys.h"

#include "CamUtility.h"

#include "CamVideoQualityLevel.h"

#include "CameraVariant.hrh" // Variant CR key values

#include "CameraappPrivateCRKeys.h" // CR keys

#include "camactivepalettehandler.h"

#include "CamAppUi.h"

#include "camsettingconversion.h"

#include "camconfiguration.h"

#include "CamStaticSettingsModel.h"

#include "CameraUiConfigManager.h"

// ===========================================================================

// Constants

const TInt KDynamicArrayGranularity  =  3;

_LIT( KCamNhdResourceFileName, "z:nhdcamsettings.rss" );  

_LIT( KCamVgaResourceFileName, "z:vgacamsettings.rss" );  

// ===========================================================================

// Local methods

inline TBool SettingIdMatches( const TInt*        aSettingId, 

                               const TIntSetting& aSettingItem )

  {

  return (*aSettingId == aSettingItem.iItemId);

  };

inline TInt FindIndex( const RPointerArray<TIntSetting>& aSettingArray,

                       const TInt&                       aSettingId    )

  {

  return aSettingArray.Find( aSettingId, SettingIdMatches );

  };

inline TInt FindIndex( const RPointerArray<TIntSetting>& aSettingArray,

                       const TIntSetting&                aSettingItem  )

  {

  return FindIndex( aSettingArray, aSettingItem.iItemId );

  };

// ===========================================================================

// Class methods

// ---------------------------------------------------------------------------

// TCamVariantInfo constructor

// ---------------------------------------------------------------------------

//

TCamVariantInfo::TCamVariantInfo() 

  : iFlags           ( -1 ),

    iTimeLapseSupport( ECamSupportUnknown ),

    iAlwaysOnSupport ( ECamSupportUnknown ),

    iVersion         ( -1, 0, 0           ) 

  {

  }

// ===========================================================================

// ---------------------------------------------------------------------------

// CCamSettingsModel::NewL

// Symbian OS two-phased constructor 

// ---------------------------------------------------------------------------

//

CCamSettingsModel* CCamSettingsModel::NewL( CCamConfiguration& aConfiguration )

    {

    CCamSettingsModel* self = CCamSettingsModel::NewLC( aConfiguration );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CCamSettingsModel::NewLC

// Symbian OS two-phased constructor

// ---------------------------------------------------------------------------

//

CCamSettingsModel* CCamSettingsModel::NewLC( CCamConfiguration& aConfiguration )

    {

    CCamSettingsModel* self = new( ELeave ) CCamSettingsModel( aConfiguration );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL

// Resets all user scene settings to their defaults without activating them.

// ---------------------------------------------------------------------------

//

void CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL()

    {

    PRINT( _L("Camera => CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL"))		

    // Reset the user scene data in the repository

    iStaticModel->ResetSettingItem( KCamCrUserSceneBaseScene );

    iStaticModel->ResetSettingItem( KCamCrUserSceneWhiteBalance );

    iStaticModel->ResetSettingItem( KCamCrUserSceneColourFilter );

    iStaticModel->ResetSettingItem( KCamCrUserSceneFlash );

    iStaticModel->ResetSettingItem( KCamCrUserSceneExposure );

    if ( iUiConfigManager->IsISOSupported() )

        {

        iStaticModel->ResetSettingItem( KCamCrUserSceneLightSensitivity );

        }

    iStaticModel->ResetSettingItem( KCamCrUserSceneContrast );

    iStaticModel->ResetSettingItem( KCamCrUserSceneImageSharpness );

    iStaticModel->ResetSettingItem( KCamCrUserSceneDefault ); 

    // Reload the static user scene settings

    iUserSceneSettings.ResetAndDestroy();

    iStaticModel->ReadFromCenRepL(

                    static_cast<TInt>( ECamSettingItemUserSceneRangeMin ),

                    static_cast<TInt>( ECamSettingItemUserSceneRangeMax ),

                    iUserSceneSettings

                   );

    PRINT( _L("Camera <= CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL"))		

    }

// ---------------------------------------------------------------------------

// CCamSettingsModel::ResetUserSceneL

// Resets all user scene settings to their defaults.

// ---------------------------------------------------------------------------

//

void CCamSettingsModel::ResetUserSceneL()

    {

    PRINT( _L("Camera => CCamSettingsModel::ResetUserSceneL"))	

    // Reset the user scene based on scene in the repository to get the default value

    ResetUserSceneWithoutActivatingChangesL();

    TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );

    // If current scene is user scene

    if ( ECamSceneUser == scene )

        {

        // if the user scene is currently the photo scene then

        // activate all the default scene settings to the AP

        ActivateUserSceneSettingsL();

        }

    PRINT( _L("Camera <= CCamSettingsModel::ResetUserSceneL"))	    

    }

// ---------------------------------------------------------------------------

// CCamSettingsModel::IntegerSettingValue

// Returns the current integer value for the specified setting

// ---------------------------------------------------------------------------

//

TInt 

CCamSettingsModel::IntegerSettingValue( TInt aSettingItem ) const

  {

  PRINT2( _L("Camera => CCamSettingsModel::IntegerSettingValue, id:%d [%s]"), 

          aSettingItem,

          KCamSettingItemNames[aSettingItem] );

  TInt value = KErrNotFound;

  // If the requested item is the photo quality value, this must

  // be filtered based on the current scene.

  if ( aSettingItem == ECamSettingItemPhotoQuality )

    {

    value = CurrentPhotoQualityValue();

    }

  // If the requested item is the photo size, this must be filtered based on

  // the current scene

  else if ( aSettingItem == ECamSettingItemPhotoSize )

    {

    value = CurrentPhotoResolution();

    }

  // If the requested item is the photo compression level, this must

  // be filtered based on the current scene, and burst mode.

  else if ( aSettingItem == ECamSettingItemPhotoCompression )

    {

    value = CurrentPhotoCompression();

    }

  else

    {

    // If we have previews active, check first if requested

    // setting is found among them. Settings model must pretend

    // that the current value is the one set to preview.

    TInt previewIndex( FindIndex( iSettingPreviews, aSettingItem ) );

    if( KErrNotFound != previewIndex )

      {

      PRINT( _L("Camera <> Setting item value in previewed currently!") );

      value = iSettingPreviews[previewIndex]->iValueId;

      if (ECamSettingItemDynamicSelfTimer == aSettingItem)     		//If the current setting Item is selftimer  

        {

        TInt settingIndex = SearchInSettingsListFor( iDynamicPhotoIntSettings, aSettingItem );  

        value = iDynamicPhotoIntSettings[settingIndex]->iValueId;	//Get the actual selftime setting value but not preview value

        }

      }

    // Otherwise, if setting item is in the dynamic photo settings return it's value.

    else if( ECamSettingItemDynamicPhotoRangeMax > aSettingItem 

          && ECamSettingItemDynamicPhotoRangeMin < aSettingItem )

      {

      TInt settingIndex = SearchInSettingsListFor( iDynamicPhotoIntSettings, aSettingItem );

      value = iDynamicPhotoIntSettings[settingIndex]->iValueId;

      }

    // Otherwise, if setting item is in the dynamic video settings return it's value.

    else if( ECamSettingItemDynamicVideoRangeMax > aSettingItem 

          && ECamSettingItemDynamicVideoRangeMin < aSettingItem )

      {

      TInt settingIndex = SearchInSettingsListFor( iDynamicVideoIntSettings, aSettingItem );

      value = iDynamicVideoIntSettings[settingIndex]->iValueId;

      }

    // Otherwise, if setting item is in the user scene settings return it's value.

    else if( ECamSettingItemUserSceneRangeMax > aSettingItem 

          && ECamSettingItemUserSceneRangeMin < aSettingItem )

      {

      TInt settingIndex = SearchInSettingsListFor( iUserSceneSettings, aSettingItem );

      value = iUserSceneSettings[settingIndex]->iValueId;

      }

    // Otherwise, if setting item is in the static video settings return it's value.

    else if( ECamSettingItemVideoClipLength == aSettingItem )

        {

        // Video clip length workaround

        // PRINT( _L("Camera <> ECamSettingItemVideoClipLength") );  

        TInt videoQuality = IntegerSettingValue( ECamSettingItemVideoQuality );

        value = iQualityLevels[videoQuality]->VideoLength();

        }

    else

        {

        value = iStaticModel->IntegerSettingValue( aSettingItem );

        }

    }

  PRINT1( _L("Camera <= CCamSettingsModel::IntegerSettingValue, value:%d"), value );

  return value;

  }

// ---------------------------------------------------------------------------

// CCamSettingsModel::SceneSettingValue

// Returns the setting value for a specific field of a scene 

// ---------------------------------------------------------------------------

//

TInt 

CCamSettingsModel::SceneSettingValue( TInt aSceneId, 

                                      TInt aSceneField ) const

  {

  PRINT2( _L("CCamSettingsModel::SceneSettingValue, scene[%s] setting[%s]"), 

          KCamSceneNames[aSceneId],

          KCamSettingItemNames[aSceneField] );

  // If setting item is a scene in the photo scene list

  TInt sceneIndex = FindSceneInSceneList( aSceneId, iPhotoScenes );

  if ( sceneIndex != KErrNotFound )

    {

    // Search for the field in the scene's field list.

    const RPointerArray<TIntSetting>& sceneSettings = 

                                        iPhotoScenes[sceneIndex]->iSettings;

    TInt fieldCount = sceneSettings.Count();

    for ( TInt i = 0; i < fieldCount; ++i )

      {

      if ( sceneSettings[i]->iItemId == aSceneField )

        {

        return sceneSettings[i]->iValueId;

        }

      }

    }

  // Otherwise if setting item is a scene in the video scene list

  sceneIndex = FindSceneInSceneList( aSceneId, iVideoScenes );

  if ( sceneIndex != KErrNotFound )

    {

    // Search for the field in the scene's field list.

    const RPointerArray<TIntSetting>& sceneSettings = 

                                        iVideoScenes[sceneIndex]->iSettings;

    TInt fieldCount = sceneSettings.Count();

    for ( TInt i = 0; i < fieldCount; ++i )

      {

      if ( sceneSettings[i]->iItemId == aSceneField )

        {

        return sceneSettings[i]->iValueId;

        }

      }

    }

  else

    {

    PRINT( _L("Camera => CCamSettingsModel::ECamPanicUnknownSettingItem 3" ))

    CamPanic( ECamPanicUnknownSettingItem );

    }

  return sceneIndex;

  }

// ---------------------------------------------------------------------------

// CCamSettingsModel::SetIntegerSettingValueL

// Sets a new integer value for the specified setting

// ---------------------------------------------------------------------------

//

void 

CCamSettingsModel::SetIntegerSettingValueL( TInt aSettingItem, 

                                            TInt aSettingValue )

  {

  PRINT ( _L("Camera => CCamSettingsModel::SetIntegerSettingValueL") );

  CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( iEnv->AppUi() );

  TCamSettingItemIds settingId( 

      static_cast<TCamSettingItemIds>(aSettingItem) );

  PRINT2( _L("Camera <> Setting item[%s] value:%d"), KCamSettingItemNames[settingId], aSettingValue );

  // -------------------------------------------------------

  // Dynamic image settings

  if( ECamSettingItemDynamicPhotoRangeMin < settingId

   && ECamSettingItemDynamicPhotoRangeMax > settingId )

    {

    TInt settingIndex = SearchInSettingsListFor( iDynamicPhotoIntSettings, 

                                                 settingId );

    iDynamicPhotoIntSettings[settingIndex]->iValueId = aSettingValue;

    // Changing scene

    if ( ECamSettingItemDynamicPhotoScene == settingId )

      {

       if ( ECamActiveCameraNone != appUi->ActiveCamera() || ( ECamActiveCameraNone == appUi->ActiveCamera() && ECamSceneAuto == aSettingValue ) )

           {

           PhotoSceneHasChangedL( aSettingValue );

           }

      }

    }

  // -------------------------------------------------------

  // Dynamic video settings

  else if( ECamSettingItemDynamicVideoRangeMin < settingId

        && ECamSettingItemDynamicVideoRangeMax > settingId )

    {

    TInt settingIndex = SearchInSettingsListFor( iDynamicVideoIntSettings, 

                                                 settingId );

    iDynamicVideoIntSettings[settingIndex]->iValueId = aSettingValue;

    if ( settingId == ECamSettingItemDynamicVideoScene )

      {

      VideoSceneHasChangedL( aSettingValue );

      }

    }

  // -------------------------------------------------------

  // User scene settings

  else if( ECamSettingItemUserSceneRangeMin < settingId

        && ECamSettingItemUserSceneRangeMax > settingId )

    {

    TBool userSceneModeSettingChanged = EFalse;

    // If the based-on scene has changed

    if ( settingId == ECamSettingItemUserSceneBasedOnScene )

      {

      TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );

      // If current scene is user scene

      if ( ECamSceneUser == scene )

        {

        // Handle other changes to the settings required by the change in scene.

        UserSceneHasChangedL( aSettingValue, ETrue );

        }

      // Otherwise the user scene hasn't been selected as the active scene

      // - the change option has just been selected in the scene setting list

      else 

        {

        // just handle a change in the scene

        UserSceneHasChangedL( aSettingValue, EFalse );

        }

      userSceneModeSettingChanged = ETrue;

      }

    // Writing values to CenRep for all the settings.

    TInt settingIndex = SearchInSettingsListFor( iUserSceneSettings, settingId );

    iUserSceneSettings[settingIndex]->iValueId = aSettingValue;

    SaveStaticSettingL( settingId );

    // If there is only one setting changed other than scene mode setting 

    // and if the Dynamic Scene mode is "User Scene" we update the new setting

    // value to the camera dynamic settings

    if ( !userSceneModeSettingChanged && settingId != ECamSettingItemUserSceneDefault ) 

      {

      TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );

      // If user scene is the currently active photo scene then activate the

      // new user scene settings.

      if ( ECamSceneUser == scene )

        {

        CopyUserSceneSettingToCaptureSettingL( settingId );

        }

      }

    }

  // -------------------------------------------------------

  else

    {

    // use the static settings model

    iStaticModel->SetIntegerSettingValueL( aSettingItem, aSettingValue );

    }

  // -------------------------------------------------------

  NotifyObservers( settingId, aSettingValue ); 

  PRINT ( _L("Camera <= CCamSettingsModel::SetIntegerSettingValueL") );

  }

// ---------------------------------------------------------------------------

// CCamSettingsModel::SetTextSettingValueL

// Sets a new text value for the specified setting

// ---------------------------------------------------------------------------

//

void CCamSettingsModel::SetTextSettingValueL( TInt aSettingItem,

                                              const TDesC& aSettingValue )

    {

    iStaticModel->SetTextSettingValueL( aSettingItem, aSettingValue );

    NotifyObservers( (TCamSettingItemIds)aSettingItem, aSettingValue );

    }

// ---------------------------------------------------------------------------

// CCamSettingsModel::TextSettingValue

// Returns the current text value for the specified setting

// ---------------------------------------------------------------------------

//

TPtrC 

CCamSettingsModel::TextSettingValue( TInt aSettingItem ) const

  {

  return iStaticModel->TextSettingValue( aSettingItem );

  }

// ---------------------------------------------------------------------------

// CCamSettingsModel::SettingValueEnabled

// Returns ETrue if the setting value is currently enabled

// ---------------------------------------------------------------------------

//

TBool CCamSettingsModel::SettingValueEnabled( TInt aSettingItem, 

                                             TInt aSettingValue ) const

    {

    TCamImageQualitySetting maxPhoto = static_cast<TCamImageQualitySetting>( iPhotoQualityLevels[iPhotoQualityLevels.Count() - 1].iPhotoResolution );

    // If the setting value is maximum photo size, and the current

    // scene is sports, then this setting value is disabled

    if ( ( aSettingItem == ECamSettingItemPhotoQuality ) && 

         ( aSettingValue == maxPhoto ) )

        {

        // If the current scene is sports, disable the option

        TCamSceneId scene = static_cast< TCamSceneId >

               ( IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) );

        if ( scene == ECamSceneSports )

            {

            return EFalse;

            }

        // Otherwise, if the current scene is the user scene and

        // it is based on the 'Sports' scene then disable the option.

        else if ( scene == ECamSceneUser ) 

            {

            // ...Get the based on scene.

            TCamSceneId baseScene = static_cast< TCamSceneId >

                ( IntegerSettingValue( ECamSettingItemUserSceneBasedOnScene ) );

            if ( baseScene == ECamSceneSports )

                {

                return EFalse;

                }

            }

        else

            {

            // Otherwise, the option is enabled

            return ETrue;

            }       

        }

    // The high quality video setting is not supported if

    // the second camera is enabled

    else if ( aSettingItem == ECamSettingItemVideoQuality && 

              aSettingValue == ECamVideoQualityHigh &&

              static_cast<CCamAppUiBase*>( 

                    iEnv->AppUi() )->IsSecondCameraEnabled() )

        {

        return EFalse;

        }

    // All other setting item values are allowed

    else 

        {

        return ETrue;

        }

    return ETrue;

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

//

void 

CCamSettingsModel

::AttachObserverL( const MCamSettingsModelObserver* aObserver )

  {

  if( aObserver )

    {

    TInt index = iObservers.Find( aObserver );

    if( KErrNotFound == index )

      {

      iObservers.AppendL( aObserver );

      }

    }

  }