/*

* 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:  Implementation of Dynamic Configuration

*

*/

#include <e32debug.h> // RDebug

#include "camconfiguration.h"

#include "camconfigurationutility.h"

#include "imagingconfigmanager.h"

#include "CamUtility.h"

#include "camconfigurationconstants.h"

const TInt KReserveedSpace = 160000;

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

// CCamConfiguration::CCamConfiguration

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

//

CCamConfiguration::CCamConfiguration():

  iPrimaryCameraDisplayId( KCamPrimaryCameraDisplayId ), 

  iSecondaryCameraDisplayId( KCamSecondaryCameraDisplayId )

  {

  } 

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

// CCamConfiguration::~CCamConfiguration

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

//  

CCamConfiguration::~CCamConfiguration()

  {

  // Quality data arrays  

  iPrimaryCameraPhotoQualities.Close();

  iSecondaryCameraPhotoQualities.Close();

  iVideoQualities.Close();

  delete iIcm;  

  // String data

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

    {

    HBufC8* str = iStrings8[i];

    iStrings8.Remove( i );

    delete str;

    }

  iStrings8.Close();    

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

    {

    HBufC16* str = iStrings16[i];

    iStrings16.Remove( i );

    delete str;

    }    

  iStrings16.Close();   

  }

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

// CCamConfiguration::NewL

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

//

CCamConfiguration*  

CCamConfiguration::NewL()

  {

  CCamConfiguration* self = new (ELeave) CCamConfiguration;

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop( self );

  return self; 

  }  

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

// CCamConfiguration::ConstructL

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

//  

void

CCamConfiguration::ConstructL()

  {

  PRINT( _L("Camera => CCamConfiguration::ConstructL") );  

  PRINT( _L("Camera <> CCamConfiguration::ConstructL - Instantiate ICM") );  

  iIcm = CImagingConfigManager::NewL();  

  PRINT( _L("Camera <> CCamConfiguration::ConstructL - Init image qualities") );  

  InitializeImageQualitiesL();

  PRINT( _L("Camera <> CCamConfiguration::ConstructL - Init video qualities") );  

  InitializeVideoQualitiesL();

  PRINT( _L("Camera <= CCamConfiguration::ConstructL") );  

  }  

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

// CCamConfiguration::InitializeImageQualitiesL

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

//  

void 

CCamConfiguration::InitializeImageQualitiesL()

  {

  PRINT( _L("Camera => CCamConfiguration::InitializeImageQualitiesL") ); 

  TInt totalLevels = iIcm->NumberOfImageQualityLevels();  

  CArrayFixFlat<TUint>* levels 

    = new (ELeave) CArrayFixFlat<TUint>( totalLevels );

  CleanupStack::PushL( levels );

  TImageQualitySet set;

  TCamImageQualityData data;

  // Get primary camera levels  

  if( iPrimaryCameraDisplayId )

    {

    PRINT( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL *** Primary camera qualities ***") ); 

    iIcm->GetImageQualityLevelsL( *levels, iPrimaryCameraDisplayId );  

    TInt numLevels( levels->Count() );

    PRINT1(_L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Total number of levels: %d"), numLevels );

    for( int i=0; i<numLevels; i++ )

      {

      iIcm->GetImageQualitySet( set, levels->At( i ), iPrimaryCameraDisplayId );

      if( set.iCamcorderVisible > 0 )

        {

        PRINT1( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Set %d CamcorderVisible"), i );

        InitializeImageQualityL( set, data );

        AddToOrderedImageQualitiesArrayL( data, iPrimaryCameraPhotoQualities );

        }

      }

    }

  // Adjust print qualities - print => print high/print/print low

  CamConfigurationUtility::AdjustPrintQualities( iPrimaryCameraPhotoQualities );  

  TInt numQualities = iPrimaryCameraPhotoQualities.Count();  

  // Get secondary camera levels

  if( iSecondaryCameraDisplayId )

    {

    PRINT( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL() *** Secondary camera qualities ***") );   

    iIcm->GetImageQualityLevelsL( *levels, iSecondaryCameraDisplayId );  

    TInt numLevels( levels->Count() );

    PRINT1( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Total number of levels: %d"), numLevels );

    for( int i=0; i<numLevels; i++ )

      {        

      iIcm->GetImageQualitySet( set, levels->At( i ), iSecondaryCameraDisplayId );

      if( set.iCamcorderVisible > 0 )

        {              

        PRINT1( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Set %d CamcorderVisible"), i );

        InitializeImageQualityL( set, data );  

        // Force image quality to secondary

        // data.iPhotoQualitySetting.iPhotoQualityId = EImageQualitySecondary;

        data.iPhotoQualitySetting.iPhotoQualityId 

            = static_cast<TCamImageQuality>( numQualities++ );

        data.iPhotoSize.iQualitySettingId = ECamImageQualitySecondary;

        AddToOrderedImageQualitiesArrayL( data, iSecondaryCameraPhotoQualities );                      

        }

      }

    }  

  CleanupStack::PopAndDestroy( levels );

  PRINT( _L("Camera <= CCamConfiguration::InitializeImageQualitiesL") );     

  }

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

// CCamConfiguration::InitializeVideoQualitiesL

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

//    

void

CCamConfiguration::InitializeVideoQualitiesL()

  {

  PRINT(_L("Camera => CCamConfiguration::InitializeVideoQualitiesL") );  

  TInt totalLevels = iIcm->NumberOfVideoQualityLevels();

  CArrayFixFlat<TUint>* levels 

    = new (ELeave) CArrayFixFlat<TUint>( totalLevels );

  CleanupStack::PushL( levels );

  TVideoQualitySet set;

  // Get primary camera levels  

  if( iPrimaryCameraDisplayId )

    {    

    iIcm->GetVideoQualityLevelsL( *levels, iPrimaryCameraDisplayId );  

    TInt numLevels( levels->Count() );

    PRINT1(_L("Camera <> CCamConfiguration::InitializeVideoQualitiesL - Total number of levels: %d"), numLevels );

    for( int i=0; i<numLevels; i++ )

      {

      iIcm->GetVideoQualitySet( set, levels->At( i ), iPrimaryCameraDisplayId );

      if( set.iCamcorderVisible > 0 )

        {      

        PRINT1(_L("Camera <> CCamConfiguration::InitializeVideoQualitiesL - Set %d CamcorderVisible"), i );

        TCamVideoQualityData data( CreateVideoQualityDataL( set ) );        

        AddToOrderedVideoQualitiesArrayL( data, iVideoQualities );                        

        }

      }

    // Set the video quality values now that we have all data in sorted array

    CamConfigurationUtility::SetVideoQualityLevels( iVideoQualities );  

    }

  // Secondary camera video qualities from ICM are ignored.

  // The last primary camera quality is used in seconcary camera as well.

  CleanupStack::PopAndDestroy( levels );

  // Get the average video bitrate scaler

  TCamcorderMMFPluginSettings mmfPluginSettings;

  User::LeaveIfError( iIcm->GetCamcorderMMFPluginSettings( mmfPluginSettings ) );

  iCMRAvgVideoBitRateScaler = mmfPluginSettings.iCMRAvgVideoBitRateScaler;

  PRINT( _L("Camera <= CCamConfiguration::InitializeVideoQualitiesL") );      

  }  

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

// CCamConfiguration::InitializeVideoQualitiesL

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

//    

void 

CCamConfiguration::AddToOrderedImageQualitiesArrayL( TCamImageQualityData& aQuality, 

                                                     RArray<TCamImageQualityData>& aArray )

  {

  TBool added = EFalse;

  TInt numQualities = aArray.Count();

  TInt numPixels = aQuality.iPhotoSize.iWidth*aQuality.iPhotoSize.iHeight;

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

    {

      if( aArray[i].iPhotoSize.iWidth*aArray[i].iPhotoSize.iHeight < numPixels )

        {

        aArray.InsertL( aQuality, i ); 

        added = ETrue;

        break;      

        }

    } 

  if( !added )

    {

    // Item is to be last in the array

    aArray.AppendL( aQuality );

    } 

  }    

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

// CCamConfiguration::AddToOrderedVideoQualitiesArrayL

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

//  

void 

CCamConfiguration::AddToOrderedVideoQualitiesArrayL( TCamVideoQualityData& aQuality,

                                                     RArray<TCamVideoQualityData>& aArray )

  {

  TBool added( EFalse );

  const TInt numQualities( aArray.Count() );

  const TInt currValue( aQuality.iDescription );

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

    {

      if( aArray[i].iDescription > currValue )

        {

        // aQuality should be before quality aArray[i]  

        aArray.InsertL( aQuality, i ); 

        added = ETrue;

        break;      

        }

    } 

  if( !added )

    {

    // Item is to be last in the array

    aArray.AppendL( aQuality );

    }     

  }

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

// CCamConfiguration::InitializeImageQualityL

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

//   

void

CCamConfiguration::InitializeImageQualityL( const TImageQualitySet& aSet, TCamImageQualityData& aData )

  {

    PRINT3( _L("Camera => CCamConfiguration::InitializeImageQualityL - res: (%d, %d), compression: %d" ), 

                                          aSet.iImageWidth, aSet.iImageHeight, aSet.iCompressionQuality );   

  // Find out the image quality/resolution id for the set

  TInt index = KErrNotFound;

  for( int i=0; i<ECamPhotoSizeLast; i++ )

    {      

    if( aSet.iImageWidth == KCamPhotoSizes[i].iWidth &&

        aSet.iImageHeight == KCamPhotoSizes[i].iHeight )

      {

      index = i;

      }

    }

  // Check that index is valid

  User::LeaveIfError( index );

  // Copy the photo size data

  aData.iPhotoSize = KCamPhotoSizes[index];

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

  // Photo quality settings

  // Set the photo resulution value, based on photo size value

  aData.iPhotoQualitySetting.iPhotoResolution

    = MapPhotoSizeToResolution( aData.iPhotoSize.iSizeId );

  // Jpeg compression  

  aData.iPhotoQualitySetting.iQualityLevel = aSet.iCompressionQuality;

  // Estimated file size

  aData.iFileSize = aSet.iEstimatedSize;        

  // Set correct image quality description, quality id and icons

  TCamImageType type = CamConfigurationUtility::ImageType( aSet.iCamcorderVisible );

  aData.iDescription = KCamImageQualityMappings[index][type].iDesc;

  if( ECamPhotoQualityDescLast == aData.iDescription )

    {

    // No description defined for this quality => not supported  

    User::Leave( KErrNotSupported );

    }  

  aData.iPhotoQualitySetting.iPhotoQualityId = KCamImageQualityMappings[index][type].iQuality;                                      

  aData.iQualityIcons = KCamImageIcons[ aData.iDescription ];                                                 

  PRINT( _L("Camera <= CCamConfiguration::InitializeImageQualityL") );

  }

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

// CCamConfiguration::GetPsiIntArrayL

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

//   

void 

CCamConfiguration::GetPsiIntArrayL( TCamPsiKey aKey, RArray<TInt>& aArray ) const

  {

  PRINT1( _L("Camera => CCamConfiguration::GetPsiIntArrayL Key: %d"), aKey );  

  switch( aKey )

    {

    case ECamPsiSupportedStillResolutions:

      {

      // Despite the name, returns array of TCamPhotoSizeId

      // The array contents must be ordered in TCamPhotoSizeId enum order

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

        {

        AppendIfSupportedL( ECamItemPhotoSize, i, aArray );            

        }      

      break;              

      }

    case ECamPsiJpegDataSizes:

      {

      // Jpeg data sizes. Must be in same order as supported still resolutions,

      // so photo size is used for indexing.  

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

        {

        AppendIfSupportedL( ECamItemPhotoSize, i, aArray, ECamItemPhotoJpegSize );            

        }      

      break;  

      }

    case ECamPsiSequencePostProcessDataSizes:

      {

      // Jpeg data sizes. Must be in same order as supported still resolutions,

      // so photo size is used for indexing.  

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

        {

        AppendIfSupportedL( ECamItemPhotoSize, i, aArray, ECamItemSeqPostProcSize );            

        }        

      break;  

      }

    case ECamPsiSupportedStillQualities:

      {

      // This is array for primary camera qualities, so do not include secondary quality.

      // The results  

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

        {

        AppendIfSupportedL( ECamItemPhotoQuality, i, aArray );            

        }        

      break;      

      } 

    case ECamPsiStillQualityIconIds:

      {   

      // Icon ids. Must be in the same order as ECamPsiSupportedStillQualities,

      // so that type is used for indexing.  

      // This is array for primary camera qualities, so do not include secondary quality.  

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

        {

        AppendIfSupportedL( ECamItemPhotoQuality, i, aArray, ECamItemSettingsIconId );            

        }        

      break;

      }   

    case ECamPsiPrecapStillQualityIconIds:

      {

      // Secondary camera quality is included  

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

        {

        AppendIfSupportedL( ECamItemPhotoQuality, i, aArray, ECamItemPrecapIconId );            

        }        

      break;                

      }

    case ECamPsiSupportedVideoResolutions:

      {

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

        {

        AppendVideoResIfSupportedL( i, aArray );  

        }

      break;  

      }

    case ECamPsiSupportedVideoQualities:

      {

      TInt n = iVideoQualities.Count();  

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

        {

        aArray.AppendL( iVideoQualities[i].iQualitySetting );  

        }      

      break;  

      }

    case ECamPsiPrecapVideoQualityIconIds:      

      {

      TInt n = iVideoQualities.Count();

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

        {

        aArray.AppendL( iVideoQualities[i].iQualityIcons.iPrecapIconId );

        aArray.AppendL( iVideoQualities[i].iQualityIcons.iPrecapIconMask );

        }  

      break;  

      }

    case ECamPsiVideoQualityIconIds:

      {

      TInt n = iVideoQualities.Count();

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

        {

        aArray.AppendL( iVideoQualities[i].iQualityIcons.iSettingsIconId );

        aArray.AppendL( iVideoQualities[i].iQualityIcons.iSettingsIconMask );

        }          

      break;  

      }

    case ECamPsiVideoQualityFileTypeId:

      {

      TInt n = iVideoQualities.Count();

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

        {

        aArray.AppendL( iVideoQualities[i].iFileTypeIcons.iIconId );

        aArray.AppendL( iVideoQualities[i].iFileTypeIcons.iMask );  

        } 

      break;   

      }   

    default:

      {

      PRINT( _L("Camera <> CCamConfiguration::GetPsiIntArrayL - Unknown key!") );

      User::Panic( KCamConfigPanicId, ECamConfigPanicUnknownKey );  

      }   

   }  

  PRINT( _L("Camera <= CCamConfiguration::GetPsiIntArrayL") );   

  }

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

// CCamConfiguration::AppendIfSupportedL

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

// 

void

CCamConfiguration::AppendIfSupportedL( TCamItemType aCheckType, TInt aValue,  

                                       RArray<TInt>&aArray, TCamItemType aAppendType ) const

  {

  TInt n( iPrimaryCameraPhotoQualities.Count() );

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

    {

    if( CamConfigurationUtility::IsSupported( aValue, aCheckType, 

                                              iPrimaryCameraPhotoQualities[i] ) )

      {

      if( ECamItemSame == aAppendType )

        {

        // Simply append the current value

        aArray.AppendL( aValue );

        }

      else

        {

        // Append something else corresponding the item  

        AppendTypeL( aAppendType, aArray, iPrimaryCameraPhotoQualities[i] );

        }

      return;

      }

    }

  n = iSecondaryCameraPhotoQualities.Count();

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

    {

    if( CamConfigurationUtility::IsSupported( aValue, aCheckType, 

                                              iSecondaryCameraPhotoQualities[i] ) )

      {

      if( ECamItemSame == aAppendType )

        {

        // Simply append the current value

        aArray.AppendL( aValue );

        }

      else

        {

        // Append something else corresponding the item  

        AppendTypeL( aAppendType, aArray, iSecondaryCameraPhotoQualities[i] );

        }

      return;  

      }   

    }    

  }