/*

* 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:  Helper class which handles reading and storing the cr keys 

 *                and its values.

 *

*/

// Includes

#include <StringLoader.h>

#include <barsread.h>

#include <e32base.h>

#include <e32const.h>

#include <centralrepository.h>

#include "CameraUiConfigManagerImp.h"

#include "CameraConfigurationCrKeys.h"

#include "camlogging.h"

#include "CamSettings.hrh"

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

// Constants

const TInt KCamCRStringInitialLength = 1024;

_LIT( KItemsSeparator, "," );

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

inline TBool SettingIdMatches( const TInt*        aSettingId, 

                               const TSupportedSettingsData& aSettingItem )

  {

  return ( *aSettingId == aSettingItem.iSettingId );

  };

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

// Class methods

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

// CCameraUiConfigManagerImp::NewL

// Symbian OS two-phased constructor 

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

//

CCameraUiConfigManagerImp* CCameraUiConfigManagerImp::NewL()

    {

    CCameraUiConfigManagerImp* self = CCameraUiConfigManagerImp::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCameraUiConfigManagerImp::NewLC

// Symbian OS two-phased constructor

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

//

CCameraUiConfigManagerImp* CCameraUiConfigManagerImp::NewLC()

    {

    CCameraUiConfigManagerImp* self = new( ELeave ) CCameraUiConfigManagerImp();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCameraUiConfigManagerImp::~CCameraUiConfigManagerImp

// Destructor

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

//

CCameraUiConfigManagerImp::~CCameraUiConfigManagerImp()

  {

  for( TInt index = 0;index <  iSupportedSettings.Count();index++ )

        {

        if ( iSupportedSettings[index] )

            {

            iSupportedSettings[index]->iSupportedSettingItems.Close();            

            }

        }

  iSupportedSettings.ResetAndDestroy();

  iSupportedSettings.Close();

  delete iRepository;

  }

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

// CCameraUiConfigManagerImp::ConstructL

// Symbian OS 2nd phase constructor

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

//

void CCameraUiConfigManagerImp::ConstructL()

    {

    iRepository = CRepository::NewL( KCameraDynamicConfigurationCrKeys );

    LoadAllDynamicSettingsL();

    }

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

// CCameraUiConfigManagerImp::IsFeatureSupported

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

//

TInt CCameraUiConfigManagerImp::IsFeatureSupported(

                                    const TCamDynamicSettings aSettingId ) const

    {

    PRINT( _L("Camera => CCameraUiConfigManagerImp::IsFeatureSupportedL" ))

    TInt settingIndex ( KErrNotFound );

    TInt value(0); // setting not supported

    if ( iSupportedSettings.Count() > 0 )

        {

        settingIndex = SearchInSettingsListFor( iSupportedSettings,

                                                static_cast<TInt>( aSettingId ) );

        }

    else

        {

        // if there are no supported settings

        }

    if ( KErrNotFound != settingIndex )

        {

        if ( iSupportedSettings[settingIndex] )

            {

            value = iSupportedSettings[settingIndex]->iSupportedValue;

            }

        }

    else

        {

        // setting item not found; hence not supported.

        }

    PRINT1( _L("Camera <= CCameraUiConfigManagerImp::IsFeatureSupportedL = %d" ), value );

    return value;

    }

//

//CCameraUiConfigManagerImp::SupportedSettingItemsL

//

void CCameraUiConfigManagerImp::SupportedSettingItemsL(

                                    const TCamDynamicSettings aSettingId,

                                    RArray<TInt>& aSupportedValues )

    {

    PRINT( _L("Camera => CCameraUiConfigManagerImp::SupportedSettingItemsL" ))

    TInt settingIndex ( KErrNotFound );

    aSupportedValues.Reset();

    if ( iSupportedSettings.Count() > 0 )

        {

        settingIndex = SearchInSettingsListFor( iSupportedSettings,

                                                static_cast<TInt>( aSettingId ) );

        }

    else

        {

        // do nothing

        }

    if ( KErrNotFound != settingIndex )

        {

        // if the index is valid, copy all corresponding setting items to the array

        for ( TInt i = 0; 

              i < iSupportedSettings[settingIndex]->iSupportedSettingItems.Count();

              i++ )

            {

            if ( iSupportedSettings[settingIndex] )

                {

                aSupportedValues.AppendL( 

                        iSupportedSettings[settingIndex]->iSupportedSettingItems[i] );

                }

            }

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    PRINT( _L("Camera <= CCameraUiConfigManagerImp::SupportedSettingItemsL" ))

    }

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

// CCameraUiConfigManager::LoadAllDynamicSettingsL

// Load all dynamic settings

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

//

void CCameraUiConfigManagerImp::LoadAllDynamicSettingsL()

    {

    PRINT( _L("Camera => CCameraUiConfigManagerImp::LoadAllDynamicSettingsL()" ))	

    RArray<TDynamicSettingsData> settingItemDefaultData;

    CleanupClosePushL( settingItemDefaultData );

    TInt supportedValue = 0;

    TInt error = KErrNone;

    for( TInt settingId = ( static_cast<TInt>( ECamDynamicSettingsMin ) + 1 ); 

              settingId <   static_cast<TInt>( ECamDynamicSettingsMax ); 

              settingId++ )

        {

        if ( LoadCrForFeatureSupport( settingId ) )

            {

            error = iRepository->Get( MapSettingItemToCrFeatureKeyL( settingId ),

                                      supportedValue );

            }

        else

            {

            supportedValue = 1;

            }

        if ( error ) break; // if any error reading CenRep; do proper clean-up

        switch( settingId )

            {

            case ECamDynamicSettingCaptureToneDelaySupport:

            case ECamDynamicSettingCaptureToneDelayValue:

            case ECamDynamicSettingRequiredRamMemory:

            case ECamDynamicSettingCriticalLevelRamMemory:

            case ECamDynamicSettingRequiredRamMemoryFocusGained:

            case ECamDynamicSettingCriticalLevelRamMemoryFocusGained:

            case ECamDynamicSettingPhoto:

            case ECamDynamicSettingPublishZoomState:

            case ECamDynamicSettingAutofocusSetInHyperfocalAtStartup:

            case ECamDynamicSettingLocation:

            case ECamDynamicSettingKeyLockWatcher:

            case ECamDynamicSettingSecondaryCamera:

            case ECamDynamicSettingLensCover:

            case ECamDynamicSettingXenonFlash:

            case ECamDynamicSettingLightSensitivity:

            case ECamDynamicSettingExtLightSensitivity:

            case ECamDynamicSettingFaceTracking:

            case ECamDynamicSettingOpticalJoyStick:

            case ECamDynamicSettingOneClickUpload:

            case ECamDynamicSettingVideoLight:

            case ECamDynamicSettingAutoFocus:

            case ECamDynamicSettingVideoStabilization:

            case ECamDynamicSettingOrientationSensor:

			case ECamDynamicSetting2ndCameraOrientation:

            case ECamDynamicSettingUIOrientationOverride:

            case ECamDynamicSettingThumbnailManagerAPI:

            case ECamDynamicSettingBurstMode:

			case ECamDynamicSettingContinuousAF: 

            case ECamDynamicSettingBurstFileSizeEstimateFactor:

                {

                PRINT1( _L("Camera <> CCameraUiConfigManagerImp::LoadAllDynamicSettingsL() append %d" ), settingId )

                AppendToSettingsArrayL( settingId,

                                        supportedValue,

                                        settingItemDefaultData );

                break;

                }

            case ECamDynamicSettingVideoSceneModeNormal:

            case ECamDynamicSettingVideoSceneModeNight:

            case ECamDynamicSettingVideoSceneModeLowLight:

            case ECamDynamicSettingDSAViewFinder:

            case ECamDynamicSettingImageSceneModeAuto:

            case ECamDynamicSettingImageSceneModeUser:

            case ECamDynamicSettingImageSceneModeMacro:

            case ECamDynamicSettingImageSceneModePotrait:

            case ECamDynamicSettingImageSceneModeScenery:

            case ECamDynamicSettingImageSceneModeSports:

            case ECamDynamicSettingImageSceneModeNight:

            case ECamDynamicSettingImageSceneModeNightPotrait:

            case ECamDynamicSettingPCCaptureKeys:

            case ECamDynamicSettingSCCaptureKeys:

            case ECamDynamicSettingPCAutoFocusKeys:

            case ECamDynamicSettingSCAutoFocusKeys:

            case ECamDynamicSettingPCZoomIn:

            case ECamDynamicSettingSCZoomIn:

            case ECamDynamicSettingPCZoomOut:

            case ECamDynamicSettingSCZoomOut:

            case ECamDynamicSettingWhiteBalance:

            case ECamDynamicSettingColorTone:

            case ECamDynamicSettingContrast:

            case ECamDynamicSettingBrightness:

            case ECamDynamicSettingEV:

            case ECamDynamicSettingSharpness:

            case ECamDynamicSettingFlashMode:

            case ECamDynamicSettingZoomLAF:

            case ECamDynamicSettingMaxOpticalZoomLimits:

            case ECamDynamicSettingMaxExtendedZoomLimits:

            case ECamDynamicSettingMaxDigitalZoomLimits:

            case ECamDynamicSettingZoomDelays:

                {

                PRINT1( _L("Camera <> CCameraUiConfigManagerImp::LoadAllDynamicSettingsL() %d" ), settingId )

                LoadConfiguredSettingItemValuesFromCrL( settingId,

                                                        supportedValue,

                                                        settingItemDefaultData );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    CleanupStack::PopAndDestroy( &settingItemDefaultData );

    User::LeaveIfError( error );

    PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadAllDynamicSettingsL()" ))

    }

//

//CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCr

//

void CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCrL(

                                       const TInt aSettingId,

                                       const TInt aSupportedValue,

                                       RArray<TDynamicSettingsData>& aDefaultItems )

    {

    PRINT( _L("Camera => CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCrL" ))		

    // Load supported setting items only when feature is supported

    LoadDefaultSettingsDataL( aSettingId, aDefaultItems );

    AppendToSettingsArrayL( aSettingId,

                            aSupportedValue,

                            aDefaultItems,

                            MapSettingItemToCrItemsKeyL( aSettingId ),

                            ETrue );

    PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadConfiguredSettingItemValuesFromCrL" ))                        

    }

//

// CCameraUiConfigManagerImp::AppendToSettingsArrayL

//

void CCameraUiConfigManagerImp::AppendToSettingsArrayL( const TInt aItemId,

                                                const TInt aSupportedValue,

                                                RArray<TDynamicSettingsData>& aAllItems,

                                                TUint32 aCrItemsKey,

                                                TBool aLoadSettingItems )

    {

    PRINT( _L("Camera => CCameraUiConfigManagerImp::AppendToSettingsArrayL" ))  	

    TSupportedSettingsData* newSetting = new( ELeave ) TSupportedSettingsData;

    CleanupStack::PushL( newSetting );

    newSetting->iSettingId = aItemId; // setting id

    newSetting->iSupportedValue     = aSupportedValue; // feature support

    if ( aLoadSettingItems && aSupportedValue )

        {

        // all configured setting items from cr only if the feature is supported

        GetSupportedSettingIdsL( aAllItems,

                                 newSetting->iSupportedSettingItems,

                                 aCrItemsKey ); 

        }

    iSupportedSettings.AppendL( newSetting );

    CleanupStack::Pop( newSetting );

    PRINT( _L("Camera <= CCameraUiConfigManagerImp::AppendToSettingsArrayL" ))  	

    }

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

// CCameraUiConfigManager::LoadAllDynamicSettingL

// Load all dynamic settings

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

//

void CCameraUiConfigManagerImp::LoadDefaultSettingsDataL(

                                         const TInt aSettingId, 

                                         RArray<TDynamicSettingsData>& aDefaultItems )

    {

    PRINT1( _L("Camera => CCameraUiConfigManagerImp::LoadDefaultSettingsDataL setting id [%d]" ), aSettingId )

    aDefaultItems.Reset();

    TInt i = 0;

    const TInt* settingsId = LoadSettingEnumerationArray( aSettingId );

    const TUint16* const* stringArray = LoadSettingStringArray( aSettingId );

    if ( settingsId && stringArray ) 

        {

        while ( settingsId[i] != KCamLastSettingItem )

            {

            TDynamicSettingsData data;

            data.iItemId = settingsId[i];

            data.iText = stringArray[i];

            aDefaultItems.AppendL( data );

            i++;

            }

        }

    PRINT( _L("Camera <= CCameraUiConfigManagerImp::LoadDefaultSettingsDataL()" ) )    

    }

//

// CCameraUiConfigManagerImp::GetSupportedSettingIdsL

//

void CCameraUiConfigManagerImp::GetSupportedSettingIdsL(

                                             RArray<TDynamicSettingsData>& aAllItems,

                                             RArray<TInt>& aSupportedValues, 

                                             const TUint32 aCrKey )

    {

    PRINT( _L("Camera => CameraUiConfigManagerImp::GetSupportedSettingIdsL" ))

    aSupportedValues.Reset();

    HBufC* string; // not sure but does this need to be in cleanupstack since this can later leave?

    string = GetStringDataL( aCrKey );

    TBool clearstring = EFalse;

    TPtrC data = string->Des();

    TPtrC currentItem( KNullDesC );

    while ( data.Length() >  0 )

        {

        // Find the next instance of item separator    

        const TInt separatorIndex( data.Find( KItemsSeparator ) );

        if( KErrNotFound != separatorIndex )    

            {

            // There is more than one item in the string still

            // Get the current item - everything before separator

            currentItem.Set( data.Left( separatorIndex ) );

            // The remaining data is now everything after the separator

            data.Set( data.Right( data.Length() - separatorIndex - 1 ) );

            }

        else

            {

            // This is the last item in the string    

            currentItem.Set( data );

            data.Set( KNullDesC );

            clearstring = ETrue;

            }

        // Get the item id for the current item, and if found, append to list

        TInt settingItem;

        PRINT1( _L("Camera <> settingItem: %S"), string )

        if ( currentItem[0]-48 >= 0 && currentItem[0]-48 <= 9 ||

           ( currentItem[0] == '-' && // check for negative number too

             currentItem[1]-48 >= 0 && currentItem[1]-48 <= 9 ) )

            {

            // read the numeric value equivalent to the numeric string

            TLex lex;

            if( currentItem.Length() > 2 ) 

                {

                // if it is hex value, then extract hex value

                if( currentItem[1] == 'x' || currentItem[1] == 'X' )

                    {

                    lex = TLex( currentItem.Mid(2) );

                    TRadix radix = EHex;

                    TUint value;

                    lex.Val(value, radix);

                    settingItem = value;

                    }

                else  // extract integer

                    {

                    lex = TLex( currentItem );

                    lex.Val( settingItem );

                    }

                }            

             else // extract integer

                {

                lex = TLex( currentItem );

                lex.Val( settingItem );

                }

            }

        else

            {

            // not a numeric string, check for necessary enum equivalents.

            settingItem = SettingItemId( aAllItems, currentItem );

            }

        PRINT1( _L("Camera <> settingItem: %d"), settingItem )

        if( KErrNotFound != settingItem )

            {

            aSupportedValues.AppendL( settingItem ); // here

            }

        if( clearstring )

            {

            delete string;

            }

        }

    PRINT( _L("Camera <= CameraUiConfigManagerImp::GetSupportedSettingIdsL" ))

    }

//

// CCameraUiConfigManagerImp::SettingItemId

//

TInt CCameraUiConfigManagerImp::SettingItemId(

                                RArray<TDynamicSettingsData>& aPossibleSettings,

                                const TDesC& aItemString ) const

    {

    PRINT( _L("Camera => CameraUiConfigManagerImp::SettingItemId" ))

    for( TInt i = aPossibleSettings.Count()-1; i >= 0; i-- )

        {     

        if( aItemString == aPossibleSettings[i].iText )

            {

            PRINT( _L("Camera <= CameraUiConfigManagerImp::SettingItemId" ))

            return aPossibleSettings[i].iItemId;

            }  

        }    

    PRINT( _L("Camera <= CameraUiConfigManagerImp::SettingItemId" ))

    // No id found for the argument string    

    return KErrNotFound;

    }

//

// CCameraUiConfigManagerImp::GetStringDataL

//

HBufC* CCameraUiConfigManagerImp::GetStringDataL( const TUint32 aCrKey )

    {

    PRINT( _L("Camera => CameraUiConfigManagerImp::GetStringDataL" ))

    HBufC* string = HBufC::NewLC( KCamCRStringInitialLength );