/*

* Copyright (c) 2006-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:  Configuration manager using Central Repositary for retrieving

*                settings for clients such as CamcorderMMFPlugin

*

*/

#include <centralrepository.h>

#include "imagingconfigmanager.h"

#include "icmcenrepkeys.h"

/*

* These constant literals are used for parsing the Central Repository strings

*

*/

_LIT( KPeriod, "." );

_LIT( KComma, "," );

_LIT( KQualitySetLevel, "QualitySetLevel" );

_LIT( KVideoFileMimeType, "VideoFileMimeType" );

_LIT( KVideoCodecMimeType, "VideoCodecMimeType" );

_LIT( KVideoWidth, "VideoWidth" );

_LIT( KVideoHeight, "VideoHeight" );

_LIT( KVideoFrameRate, "VideoFrameRate" );

_LIT( KVideoBitRate, "VideoBitRate" );

_LIT( KVideoEncoderUID, "VideoEncoderUID=0" ); // "=0" there is a way to

                                             // ignore the "0x" from the

                                             // beginning of hex-number

_LIT( KRandomAccessRate, "RandomAccessRate" );

_LIT( KVideoPixelAspectRatioNum, "VideoPixelAspectRatioNum" );

_LIT( KVideoPixelAspectRatioDenom, "VideoPixelAspectRatioDenom" );

_LIT( KPreferredSupplier, "PreferredSupplier" );

_LIT( KAudioFourCCType, "AudioFourCCType" );

_LIT( KAudioBitrate, "AudioBitrate" );

_LIT( KAudioSamplingRate, "AudioSamplingRate" );

_LIT( KAudioChannels, "AudioChannels" );

_LIT( KAudioEncoderUID, "AudioEncoderUID=0" ); // "=0" there is a way to

                                             // ignore the "0x" from the

                                             // beginning of hex-number

_LIT( KAVSyncStartDelay, "AVSyncStartDelay" );

_LIT( KAVSyncResumeDelay, "AVSyncResumeDelay" );

_LIT( KCameraDisplayId, "CameraDisplayId" );

_LIT( KCamcorderVisible, "CamcorderVisible" );

_LIT( KVideoNightFrameRate, "VideoNightFrameRate" );

_LIT( KCMRAvgVideoBitRateScaler, "CMRAvgVideoBitRateScaler" );

_LIT( KVideoComplexitySetting, "VideoComplexitySetting" );

_LIT( KCMRLatencyQualityTradeoff, "CMRLatencyQualityTradeoff" );

_LIT( KCMRPictureQuality, "CMRPictureQuality" );

_LIT( KCMRQualityTemporalTradeoff, "CMRQualityTemporalTradeoff" );

_LIT( KCMRNumCameraBuffers, "CMRNumCameraBuffers" );

_LIT( KCMRNumCameraBuffersARM, "CMRNumCameraBuffersARM" );

_LIT( KCMRMinNumOutputBuffers, "CMRMinNumOutputBuffers" );

_LIT( KImageFileMimeType, "ImageFileMimeType" );

_LIT( KImageWidth, "ImageWidth" );

_LIT( KImageHeight, "ImageHeight" );

_LIT( KImageFileExtension, "ImageFileExtension" );

_LIT( KImageEncoderUID, "ImageEncoderUID=0" ); // "=0" there is a way to

                                             // ignore the "0x" from the

                                             // beginning of hex-number

_LIT( KCompressionQuality, "CompressionQuality" );

_LIT( KEstimatedSize, "EstimatedSize" );

// Constants used in Central Repository parsing and granularity

const TInt KGranularity = 1;

const TUint32 KRowMask = 0xFFFF0000;

const TUint32 KRowVideo = 1 << 16;  // VideoQualitySets' offset

const TUint32 KRowCCor = 2 << 16;   // CamcorderMMFPluginSettings' offset

const TUint32 KRowImage = 3 << 16;  // ImageQualitySets' offset

const TText8 KZero = '\0';          // null-termination mark of strings

const TInt KInitBufSize = 1;        // Initial size of reserved buffer

const TInt KUndefined = -1;         // used as initial undefined value

// ======== MEMBER FUNCTIONS ========

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

// Constructor of CImagingConfigManager

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

//

CImagingConfigManager::CImagingConfigManager()

    {

    }

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

// Destructor of CImagingConfigManager

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

//

CImagingConfigManager::~CImagingConfigManager()

    {

    if( iVideoQualitySets )

        {

        iVideoQualitySets->Reset();

        delete iVideoQualitySets;

        }

    if( iImageQualitySets )

        {

        iImageQualitySets->Reset();

        delete iImageQualitySets;

        }

    }

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

// ConstructL() of CImagingConfigManager

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

//

void CImagingConfigManager::ConstructL()

    {

    RArray< TUint32 > foundCols; // This is used for fetching the columns of

                                 // data from Central Repository

    TInt buffersize = KInitBufSize; // buffer variable's size

    HBufC* buffer = NULL;        // Common buffer to be used for temporary

                                 // storage for reads from Central Repository

    TInt keyCount;               // Number of keys found from CenRep

    TUint uidtemp = 0;           // Temp TUint storage for UIDs

    // Create the repository

    CRepository *repository = CRepository::NewLC( KCRUidImagingConfigManager );

    // Alloc quality sets

    iVideoQualitySets =

            new ( ELeave ) CArrayFixFlat< TVideoQualitySet >( KGranularity );

    iImageQualitySets =

            new ( ELeave ) CArrayFixFlat< TImageQualitySet >( KGranularity );

    // Find video quality setting sets by using the KRowMask

    User::LeaveIfError( repository->FindL( KRowVideo, KRowMask, foundCols ) );

    buffer = HBufC::NewLC( buffersize );

    keyCount = foundCols.Count();

    // For each key, parse the settings into the TVideoQualitySet

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

        {

        TVideoQualitySet tmpVideoQualitySet;

        TPtr ptr = buffer->Des();

        buffersize = 0;

        // String with settings is fetched from CenRep

        TInt ret = repository->Get( foundCols[ i ], ptr, buffersize );

        // KErrOverFlow is returned if and when 1 is not big enough size

        // for buffer

        if ( ret == KErrOverflow )

            {

            // More space is reserved

            CleanupStack::PopAndDestroy(); // buffer

            buffer = HBufC::NewLC( buffersize );

            ptr.Set( buffer->Des() );

            User::LeaveIfError( repository->Get( foundCols[ i ], ptr ) );

            }

        else

            {

            User::LeaveIfError( ret );

            }

        // Fetched string is parsed right and left and the value is stored

        // to suitable form into the TVideoQualitySet

        TPtrC temp = GetRightPartL( ptr, KQualitySetLevel() );

        TLex lextemp = GetLeftPart( temp );

        TBuf<1024> treal;

        User::LeaveIfError( lextemp.Val(

                    tmpVideoQualitySet.iVideoQualitySetLevel, EDecimal ) );

        temp.Set( GetRightPartL( ptr, KVideoFileMimeType() ) );

        temp.Set( GetLeftPart( temp ) );

        SetTextStringL( temp, tmpVideoQualitySet.iVideoFileMimeType );

        temp.Set( GetRightPartL( ptr, KVideoCodecMimeType() ) );

        temp.Set( GetLeftPart( temp ) );

        SetTextStringL( temp, tmpVideoQualitySet.iVideoCodecMimeType );

        temp.Set( GetRightPartL( ptr, KVideoWidth() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iVideoWidth ) );

        temp.Set( GetRightPartL( ptr, KVideoHeight() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iVideoHeight ) );

        temp.Set( GetRightPartL( ptr, KVideoFrameRate() ) );

        temp.Set( GetLeftPart( temp ) );

        treal = temp;

        TLocale tlocale;

        TChar ch = tlocale.DecimalSeparator();

        if( temp.Find( KPeriod ) >= 0 )

            {

            treal[temp.Find( KPeriod )] = ch;

            }

        lextemp = treal;

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iVideoFrameRate ) );

        temp.Set( GetRightPartL( ptr, KVideoBitRate() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iVideoBitRate ) );

        temp.Set( GetRightPartL( ptr, KVideoEncoderUID() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( uidtemp, EHex ) );

        tmpVideoQualitySet.iVideoEncoderUID.iUid = uidtemp;

        temp.Set( GetRightPartL( ptr, KRandomAccessRate() ) );

        temp.Set( GetLeftPart( temp ) );

        treal = temp;

        if( temp.Find( KPeriod ) >= 0 )

            {

            treal[temp.Find( KPeriod )] = ch;

            }

        lextemp = treal;

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iRandomAccessRate ) );

        temp.Set( GetRightPartL( ptr, KVideoPixelAspectRatioNum() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val(

                    tmpVideoQualitySet.iVideoPixelAspectRatioNum ) );

        temp.Set( GetRightPartL( ptr, KVideoPixelAspectRatioDenom() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val(

                    tmpVideoQualitySet.iVideoPixelAspectRatioDenom ) );

        temp.Set( GetRightPartL( ptr, KPreferredSupplier() ) );

        temp.Set( GetLeftPart( temp ) );

        SetTextStringL( temp, tmpVideoQualitySet.iPreferredSupplier );

        temp.Set( GetRightPartL( ptr, KAudioFourCCType() ) );

        temp.Set( GetLeftPart( temp ) );

        TBuf8<4> fourccbuf8;

        fourccbuf8.Copy(temp);

        tmpVideoQualitySet.iAudioFourCCType.Set(fourccbuf8);

        TUint32 intti = tmpVideoQualitySet.iAudioFourCCType.FourCC();

        temp.Set( GetRightPartL( ptr, KAudioBitrate() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iAudioBitRate ) );

        temp.Set( GetRightPartL( ptr, KAudioSamplingRate() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val(

                    tmpVideoQualitySet.iAudioSamplingRate ) );

        temp.Set( GetRightPartL( ptr, KAudioChannels() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iAudioChannels ) );

        temp.Set( GetRightPartL( ptr, KAudioEncoderUID() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( uidtemp, EHex ) );

        tmpVideoQualitySet.iAudioEncoderUID.iUid = uidtemp;

        temp.Set( GetRightPartL( ptr, KAVSyncStartDelay() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iAVSyncStartDelay ) );

        temp.Set( GetRightPartL( ptr, KAVSyncResumeDelay() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val(

                    tmpVideoQualitySet.iAVSyncResumeDelay ) );

        temp.Set( GetRightPartL( ptr, KCameraDisplayId() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iCameraDisplayId ) );

        temp.Set( GetRightPartL( ptr, KCamcorderVisible() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpVideoQualitySet.iCamcorderVisible ) );

        iVideoQualitySets->AppendL( tmpVideoQualitySet );

        }

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

        {

        foundCols.Remove( i );

        }

    User::LeaveIfError( repository->FindL( KRowCCor, KRowMask, foundCols ) );

    keyCount = foundCols.Count();

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

        {

        TPtr ptr = buffer->Des();

        buffersize = 0;

        TInt ret = repository->Get( foundCols[ i ], ptr, buffersize );

        if ( ret == KErrOverflow )

            {

            CleanupStack::PopAndDestroy(); // buffer

            buffer = HBufC::NewLC( buffersize );

            ptr.Set( buffer->Des() );

            User::LeaveIfError( repository->Get( foundCols[ i ], ptr ) );

            }

        else if( ret != KErrNone )

            {

            User::LeaveIfError( ret );

            }

        else

            {

            }

        TBuf<1024> treal;    

        TPtrC temp = GetRightPartL( ptr, KVideoNightFrameRate() );

        temp.Set( GetLeftPart( temp ) );

        treal = temp;

        TLocale tlocale;

        TChar ch = tlocale.DecimalSeparator();

        if( temp.Find( KPeriod ) >= 0 )

            {

            treal[temp.Find( KPeriod )] = ch;

            }

        TLex lextemp(treal);

        User::LeaveIfError( lextemp.Val(

                    iCamcorderMMFPluginSettings.iVideoNightFrameRate ) );

        temp.Set( GetRightPartL( ptr, KCMRAvgVideoBitRateScaler() ) );

        temp.Set( GetLeftPart( temp ) );

        treal = temp;

        if( temp.Find( KPeriod ) >= 0 )

            {

            treal[temp.Find( KPeriod )] = ch;

            }

        lextemp = treal;

        User::LeaveIfError( lextemp.Val(

                    iCamcorderMMFPluginSettings.iCMRAvgVideoBitRateScaler ) );

        temp.Set( GetRightPartL(ptr, KVideoComplexitySetting() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val(

                    iCamcorderMMFPluginSettings.iVideoComplexitySetting ) );

        temp.Set( GetRightPartL( ptr, KCMRLatencyQualityTradeoff() ) );

        temp.Set( GetLeftPart( temp ) );

        treal = temp;

        if( temp.Find( KPeriod ) >= 0 )

            {

            treal[temp.Find( KPeriod )] = ch;

            }

        lextemp = treal;

        User::LeaveIfError( lextemp.Val(

                    iCamcorderMMFPluginSettings.iCMRLatencyQualityTradeoff ) );

        temp.Set( GetRightPartL( ptr, KCMRPictureQuality() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val(

                    iCamcorderMMFPluginSettings.iCMRPictureQuality ) );

        temp.Set( GetRightPartL( ptr, KCMRQualityTemporalTradeoff() ) );

        temp.Set( GetLeftPart( temp ) );

        treal = temp;

        if( temp.Find( KPeriod ) >= 0 )

            {

            treal[temp.Find( KPeriod )] = ch;

            }

        lextemp = treal;

        User::LeaveIfError( lextemp.Val(

                    iCamcorderMMFPluginSettings.iCMRQualityTemporalTradeoff ) );

        if(ptr.Find(KCMRNumCameraBuffers()) >= 0)

            {

            temp.Set( GetRightPartL( ptr, KCMRNumCameraBuffers() ) );

            lextemp = GetLeftPart( temp );

            User::LeaveIfError( lextemp.Val(

                        iCamcorderMMFPluginSettings.iCMRNumCameraBuffers ) );

            temp.Set( GetRightPartL( ptr, KCMRNumCameraBuffersARM() ) );

            lextemp = GetLeftPart( temp );

            User::LeaveIfError( lextemp.Val(

                        iCamcorderMMFPluginSettings.iCMRNumCameraBuffersARM ) );

            temp.Set( GetRightPartL( ptr, KCMRMinNumOutputBuffers() ) );

            lextemp = GetLeftPart( temp );

            User::LeaveIfError( lextemp.Val(

                        iCamcorderMMFPluginSettings.iCMRMinNumOutputBuffers ) );

            }

        else

            {

            // To ensure backwards compatibility we give these three new

            // settings default values of 2, 1 and 4 respectively according

            // to old implementation in MMFPlug-in

            iCamcorderMMFPluginSettings.iCMRNumCameraBuffers = 2;

            iCamcorderMMFPluginSettings.iCMRNumCameraBuffersARM = 1;

            iCamcorderMMFPluginSettings.iCMRMinNumOutputBuffers = 4;

            }

        }

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

        {

        foundCols.Remove( i );

        }

    User::LeaveIfError( repository->FindL( KRowImage, KRowMask, foundCols ) );

    keyCount = foundCols.Count();

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

        {

        TPtr ptr = buffer->Des();

        buffersize = 0;

        TInt ret = repository->Get( foundCols[ i ], ptr, buffersize );

        if ( ret == KErrOverflow )

            {

            CleanupStack::PopAndDestroy(); // buffer

            buffer = HBufC::NewLC( buffersize );

            ptr.Set( buffer->Des() );

            User::LeaveIfError( repository->Get( foundCols[ i ], ptr ) );

            }

        else if( ret != KErrNone )

            {

            User::LeaveIfError( ret );

            }

        else

            {

            }

        TImageQualitySet tmpImageQualitySet;

        TPtrC temp = GetRightPartL( ptr, KQualitySetLevel() );

        TLex lextemp( GetLeftPart( temp ) );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iImageQualitySetLevel,

                                       EDecimal ) );

        temp.Set( GetRightPartL( ptr, KImageFileMimeType() ) );

        temp.Set( GetLeftPart( temp ) );

        SetTextStringL( temp, tmpImageQualitySet.iImageFileMimeType );

        temp.Set( GetRightPartL( ptr, KImageWidth() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iImageWidth ) );

        temp.Set( GetRightPartL( ptr, KImageHeight() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iImageHeight ) );

        temp.Set( GetRightPartL( ptr, KImageFileExtension() ) );

        temp.Set( GetLeftPart( temp ) );

        SetTextStringL( temp, tmpImageQualitySet.iImageFileExtension );

        temp.Set( GetRightPartL( ptr, KImageEncoderUID() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( uidtemp, EHex ) );

        tmpImageQualitySet.iImageEncoderUID.iUid = uidtemp;

        temp.Set( GetRightPartL( ptr, KCompressionQuality() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iCompressionQuality ) );

        temp.Set( GetRightPartL( ptr, KEstimatedSize() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iEstimatedSize ) );

        temp.Set( GetRightPartL( ptr, KCameraDisplayId() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iCameraDisplayId ) );

        temp.Set( GetRightPartL( ptr, KCamcorderVisible() ) );

        lextemp = GetLeftPart( temp );

        User::LeaveIfError( lextemp.Val( tmpImageQualitySet.iCamcorderVisible ) );

        iImageQualitySets->AppendL( tmpImageQualitySet );

        }

    foundCols.Close();

    CleanupStack::PopAndDestroy(); // buffer

    CleanupStack::PopAndDestroy( repository );

    }

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

// CheckIfNegative( TInt aValue ) of CImagingConfigManager, private method

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

//

TBool CImagingConfigManager::CheckIfNegative( const TInt aValue ) const

    {

    TBool retval = EFalse;

    if( aValue < 0 )

        {

        retval = ETrue;

        }

    return retval;

    }

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

// GetRightPartL( TPtr aPtr, const TDesC& aSearchable ) of 

// CImagingConfigManager, private method

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

//

TPtrC CImagingConfigManager::GetRightPartL( const TPtr& aPtr,

                                            const TDesC& aSearchable ) const

    {

    // First verify the values so that we know if they aren't legal

    if( CheckIfNegative( aPtr.Find( aSearchable ) ) ||

        CheckIfNegative( ( ( aPtr.Length() -

                             aPtr.Find( aSearchable ) ) -

                           aSearchable.Length() ) - 1 ) )

        {

        User::Leave( KErrGeneral );

        }

    return aPtr.Right( ( ( aPtr.Length() -

                           aPtr.Find( aSearchable ) ) -

                         aSearchable.Length() ) - 1 );

    }

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

// GetLeftPartL( TPtrC aPtrc ) of CImagingConfigManager, private method

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

//

TPtrC CImagingConfigManager::GetLeftPart( const TPtrC& aPtrc ) const

    {

    if( CheckIfNegative( aPtrc.Find( KComma ) ) )

        {

        return aPtrc;

        }

    return aPtrc.Left( aPtrc.Find( KComma ) );

    }

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

// SetTextStringL( TPtrC& aPtr, TText8& aStringToFill ) of

// CImagingConfigManager,private method

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

//

void CImagingConfigManager::SetTextStringL( const TPtrC& aPtr,

                                            TText8* aStringToFill ) const

    {

    if( static_cast< TUint >( aPtr.Length() ) > KMaxStringLength )

        {

        User::Leave( KErrOverflow );

        }

    if( aStringToFill == NULL )