/*

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

    const RPointerArray<TIntSetting> *iStaticIntSettings=NULL;

    // If setting item is in the static photo settings return it's value.

    if( ECamSettingItemStaticPhotoRangeMax > aSettingItem

        && ECamSettingItemStaticPhotoRangeMin < aSettingItem )

      {

        iStaticIntSettings=&iStaticPhotoIntSettings;

      }

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

    else if( ECamSettingItemStaticVideoRangeMax > aSettingItem 

          && ECamSettingItemStaticVideoRangeMin < aSettingItem )

      {

        iStaticIntSettings=&iStaticVideoIntSettings;

      }

    // Look in static common settings.

    else if( ECamSettingItemStaticCommonRangeMax > aSettingItem

          && ECamSettingItemStaticCommonRangeMin < aSettingItem )

      {

        iStaticIntSettings=&iStaticCommonIntSettings;

      }

    else

      {

      PRINT( _L("Camera <> Not found, PANIC !! ECamPanicUnknownSettingItem" ))

      CamPanic( ECamPanicUnknownSettingItem );

      }

    if( iStaticIntSettings )

        {

        TInt settingIndex = SearchInSettingsListFor(

                                                    *iStaticIntSettings,

                                                    aSettingItem );

        if( settingIndex < iStaticIntSettings->Count() && settingIndex >= 0 )

            {

            value = (*iStaticIntSettings)[settingIndex]->iValueId;

            }

        }

    return value;

    }

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

// CCamStaticSettingsModel::SetIntegerSettingValueL

// Sets a new integer value for the specified setting

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

//

void 

CCamStaticSettingsModel::SetIntegerSettingValueL( TInt aSettingItem,

                                                  TInt aSettingValue )

  {

  TCamSettingItemIds settingId(

      static_cast<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") );