diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/common/src/camconfiguration.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/common/src/camconfiguration.cpp	Wed Sep 01 12:30:54 2010 +0100
@@ -0,0 +1,1198 @@
+/*
+* 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;  
+      }   
+    }    
+  }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AppendTypeL
+// ---------------------------------------------------------------------------
+// 
+void
+CCamConfiguration::AppendTypeL( TCamItemType aType, RArray<TInt>&aArray, const TCamImageQualityData& aData )
+  {
+  switch( aType )
+    {
+    case ECamItemSettingsIconId:
+      {
+      aArray.AppendL( aData.iQualityIcons.iSettingsIconId );
+      aArray.AppendL( aData.iQualityIcons.iSettingsIconMask );  
+      break;
+      }
+    case ECamItemPrecapIconId:
+      {
+      aArray.AppendL( aData.iQualityIcons.iPrecapIconId );
+      aArray.AppendL( aData.iQualityIcons.iPrecapIconMask );  
+      break;
+      }      
+    case ECamItemPhotoJpegSize:
+      {
+      aArray.AppendL( aData.iFileSize );
+      break;  
+      }
+    case ECamItemSeqPostProcSize:
+      {
+      aArray.AppendL( aData.iFileSize );  
+      break;
+      }        
+    default:
+      {
+      User::Panic( KCamConfigPanicId, ECamConfigPanicUnknownType );    
+      }  
+    }  
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NumImageQualities
+// ---------------------------------------------------------------------------
+//   
+TInt
+CCamConfiguration::NumImageQualities() const
+  {
+  TInt count( iPrimaryCameraPhotoQualities.Count() );
+  if( iSecondaryCameraPhotoQualities.Count() > 0 )
+    {
+    // Only one quality currently supported for secondary cam   
+    count++;
+    // count += iSecondaryCameraPhotoQualities.Count();
+    }
+    
+  return count;   
+  }
+  
+// ---------------------------------------------------------------------------
+// CCamConfiguration::SecondaryCameraImageQuality
+// ---------------------------------------------------------------------------
+//   
+TInt
+CCamConfiguration::MmsImageQuality() const
+  {
+  // As the primary camera image qualities are sorted, MMS quality is the
+  // last one in the qualities array.
+  TInt index = iPrimaryCameraPhotoQualities.Count()-1;
+  
+  return index < 0 ?
+    KErrNotFound :
+    iPrimaryCameraPhotoQualities[index].iPhotoQualitySetting.iPhotoQualityId;
+  }
+  
+  
+// ---------------------------------------------------------------------------
+// CCamConfiguration::SecondaryCameraImageQuality
+// ---------------------------------------------------------------------------
+//    
+TInt
+CCamConfiguration::SecondaryCameraImageQuality() const
+  {
+  if( iSecondaryCameraPhotoQualities.Count() > 0 )
+    {
+    return iSecondaryCameraPhotoQualities[0].iPhotoQualitySetting.iPhotoQualityId;   
+    }
+  
+  return KErrNotFound;      
+  }  
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ImageQuality
+// ---------------------------------------------------------------------------
+//  
+const TCamPhotoQualitySetting&
+CCamConfiguration::ImageQuality( TInt aIndex ) const
+  {
+  const TInt count( iPrimaryCameraPhotoQualities.Count() );
+  if( aIndex >= 0 && aIndex < count )
+    {
+    return iPrimaryCameraPhotoQualities[aIndex].iPhotoQualitySetting;  
+    }
+  else
+    {
+    TInt secIndex = aIndex - count;
+    if( secIndex >= 0 &&
+        secIndex < iSecondaryCameraPhotoQualities.Count() )
+      {
+      return iSecondaryCameraPhotoQualities[secIndex].iPhotoQualitySetting;  
+      }
+
+    User::Panic( KCamConfigPanicId, ECamConfigPanicNoQuality ); 
+    return iPrimaryCameraPhotoQualities[0].iPhotoQualitySetting; // Get rid of warning   
+    }
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ImageQualityData
+// ---------------------------------------------------------------------------
+// 
+const TCamImageQualityData&
+CCamConfiguration::ImageQualityData( TInt aIndex ) const
+  { 
+  const TInt count( iPrimaryCameraPhotoQualities.Count() );
+  if( aIndex >= 0 && aIndex < count )
+    {
+    return iPrimaryCameraPhotoQualities[aIndex];  
+    }
+  else
+    {
+    TInt secIndex = aIndex - count;
+    if( secIndex >= 0 &&
+        secIndex < iSecondaryCameraPhotoQualities.Count() )
+      {
+      return iSecondaryCameraPhotoQualities[secIndex];  
+      }
+
+    User::Panic( KCamConfigPanicId, ECamConfigPanicNoQuality );
+    return iPrimaryCameraPhotoQualities[0]; // Get rid of warning
+    }
+  } 
+  
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NumVideoQualities
+// ---------------------------------------------------------------------------
+//  
+TInt
+CCamConfiguration::NumVideoQualities() const
+  {
+  return iVideoQualities.Count();   
+  }
+  
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NumPrimaryImageQualities
+// ---------------------------------------------------------------------------
+//  
+TInt
+CCamConfiguration::NumPrimaryImageQualities() const
+  {
+  return iPrimaryCameraPhotoQualities.Count();
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::SecondaryCameraVideoQuality
+// ---------------------------------------------------------------------------
+//    
+TInt
+CCamConfiguration::SecondaryCameraVideoQuality() const
+  {
+  // Currently always the last of the video qualities  
+  // Currently always the last of the video qualities
+  // As the camera video qualities are sorted, sharing quality is the
+  // last one in the qualities array.
+  TInt index = NumVideoQualities()-1;
+  
+  return index < 0 ?
+    KErrNotFound :
+    iVideoQualities[index].iQualitySettings.iQualityLevel;
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::VideoQualitySetting
+// ---------------------------------------------------------------------------
+//  
+TInt
+CCamConfiguration::VideoQualitySetting( TInt aIndex ) const
+  {
+  return iVideoQualities[aIndex].iQualitySetting;
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::VideoQuality
+// ---------------------------------------------------------------------------
+//  
+const TVideoQualitySettings&
+CCamConfiguration::VideoQuality( TInt aIndex ) const
+  {
+  return iVideoQualities[aIndex].iQualitySettings;
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapSupportedQualityToQualityDescriptor
+// ---------------------------------------------------------------------------
+//  
+TInt
+CCamConfiguration::MapSupportedQualityToQualityDescriptor( TBool aVideoMode,
+                                                           TInt aQualityVal ) const
+  {
+  if( aVideoMode )
+    {
+    // Video mode
+    TInt n = iVideoQualities.Count();
+    for( TInt i=0; i<n; i++ )
+      { 
+      const TCamVideoQualityData& data = iVideoQualities[i];
+      if( aQualityVal == data.iQualitySetting )
+        {
+        return data.iDescription;
+        }
+      }
+    
+    // No description found for this quality => Not supported
+    User::Panic( KCamConfigPanicId, ECamConfigPanicNoDescription );       
+    return KErrNotSupported;
+    }
+  else
+    {
+    // Image mode
+    TInt n = iPrimaryCameraPhotoQualities.Count();
+    for( TInt i=0; i<n; i++ )
+      {
+      const TCamImageQualityData& data = iPrimaryCameraPhotoQualities[i];
+      if( aQualityVal == data.iPhotoSize.iQualitySettingId )
+        {
+        return data.iDescription;
+        }
+      }
+    
+    // No description found for this quality value => Not supported
+    User::Panic( KCamConfigPanicId, ECamConfigPanicNoDescription );  
+    return KErrNotSupported;
+    }                                                             
+  
+  }
+  
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapPhotoSizeToResolution
+// ---------------------------------------------------------------------------
+//    
+TCamImageResolution 
+CCamConfiguration::MapPhotoSizeToResolution( TCamPhotoSizeId aSizeId ) 
+  {
+  for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+    {
+    if( KCamPhotoSizes[i].iSizeId == aSizeId )
+      {
+      return KCamPhotoSizes[i].iResolution;
+      }
+    }  
+  // Used as deafult in previous implementation  
+  return EImageResolutionMMS;    
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapResolutionToPhotoSize
+// ---------------------------------------------------------------------------
+//   
+TCamPhotoSizeId 
+CCamConfiguration::MapResolutionToPhotoSize( TCamImageResolution aResolution )  
+  {
+  for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+    {
+    if( KCamPhotoSizes[i].iResolution == aResolution )
+      {
+      return KCamPhotoSizes[i].iSizeId;
+      }
+    }  
+  // Used as deafult in previous implementation  
+  return ECamPhotoSizeVGA;    
+  }    
+ 
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ImagesRemaining
+// ---------------------------------------------------------------------------
+//  
+TInt
+CCamConfiguration::ImagesRemaining( TCamMediaStorage aStorage,
+                                    TCamPhotoSizeId aSizeId, 
+                                    TInt aCriticalLevel, 
+                                    TBool /*aBurstActive*/ ) const
+  {
+    // PRINT( _L("Camera => CamUtility::ImagesRemaining") );
+    TInt64 memoryfree = 0;
+
+    // Get the current amount of free memory on the phone.
+    switch ( aStorage )
+        {
+    case ECamMediaStoragePhone:
+        memoryfree 
+          = CamUtility::MemoryFree( DriveInfo::EDefaultPhoneMemory,
+                                    aCriticalLevel );          
+        break;
+
+    case ECamMediaStorageCard:
+	    PRINT( _L("Camera => CamUtility::ImagesRemaining, ECamMediaStorageCard") );
+        memoryfree 
+          = CamUtility::MemoryFree( DriveInfo::EDefaultRemovableMassStorage,
+                                    aCriticalLevel );
+        break;
+
+    case ECamMediaStorageMassStorage:
+	    PRINT( _L("Camera => CamUtility::ImagesRemaining, ECamMediaStorageMassStorage") );
+        memoryfree 
+          = CamUtility::MemoryFree( DriveInfo::EDefaultMassStorage,
+                                    aCriticalLevel );
+        break;
+    default:
+	    PRINT( _L("Camera => CamUtility::ImagesRemaining, default") );
+        break;
+        };    
+        
+  TInt size = 1;        
+  
+  TInt n=NumImageQualities();
+  for( TInt i=0; i<n; i++ )
+    {
+    const TCamImageQualityData& data( ImageQualityData( i ) );
+    if( aSizeId == data.iPhotoSize.iSizeId )
+      {
+      size = data.iFileSize;  
+      }      
+    }
+  
+   memoryfree -= KReserveedSpace;  
+  // In the case of exceptional circumstances, just return zero images remaining.
+  if ( memoryfree <= 0 )
+  	{
+  	memoryfree = 0;  // To handle exceptional situation, just return zero images.
+  	} 
+  
+  TInt64 images = memoryfree / size;      
+
+  images = Min( KMaxTInt, images ); // Truncate value to max possible.
+
+  // PRINT1( _L("Camera <= CamUtility::ImagesRemaining %d"), (TInt)images );
+  return static_cast<TInt>( images );  // (nothing greater than TInt)                      
+  } 
+ 
+ 
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AllocString8L
+// ---------------------------------------------------------------------------
+//  
+const TUint8*  
+CCamConfiguration::AllocString8L( const TUint8* aData )
+  {  
+  TPtrC8 ptr( aData );
+  HBufC8* data = HBufC8::NewLC( ptr.Length() + 1 );
+  data->Des().Copy( ptr );
+  data->Des().Append( '\0' );
+  
+  iStrings8.AppendL( data );
+  
+  CleanupStack::Pop( data );
+  
+  return data->Ptr();
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AllocString16L
+// ---------------------------------------------------------------------------
+// 
+const TUint16*
+CCamConfiguration::AllocString16L( const TUint8* aData )
+  {
+  TPtrC8 ptr( aData );
+  HBufC16* data = HBufC16::NewLC( ptr.Length() + 1 );
+  data->Des().Copy( ptr );
+  data->Des().Append( '\0' );
+  
+  iStrings16.AppendL( data );
+  
+  CleanupStack::Pop( data );
+
+  return data->Ptr();
+  }  
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::CreateVideoQualityDataL
+// ---------------------------------------------------------------------------
+// 
+TCamVideoQualityData
+CCamConfiguration::CreateVideoQualityDataL( const TVideoQualitySet& aSet )
+  {       
+  PRINT3( _L("Camera => CCamConfiguration::CreateVideoQualityDataL - res: (%d, %d), video bitrate: %d" ), 
+                                          aSet.iVideoWidth, aSet.iVideoHeight, aSet.iVideoBitRate ); 
+    
+  TInt resIndex( CamConfigurationUtility::VideoSizeIndex( 
+            aSet.iVideoWidth, aSet.iVideoHeight ) );
+  if( resIndex < 0 )
+    {
+    User::Panic( KCamConfigPanicId, ECamConfigPanicNoVideoRes );  
+    }
+        
+  TCamVideoQualityDescription descType 
+      = CamConfigurationUtility::VideoDescId( aSet.iCamcorderVisible ); 
+      
+  TInt videoType = CamConfigurationUtility::VideoType( aSet.iVideoFileMimeType );    
+  
+  // Convert FourCC value from TFourCC to asciiz string
+  const TInt KFourCCLength = 5; // 4 characters + '\0'
+  TText8 fourCCBuf[KFourCCLength ];
+  TPtr8 fourCC( fourCCBuf, KFourCCLength );
+  aSet.iAudioFourCCType.FourCC( &fourCC );
+  fourCC.Append( '\0' );  
+  
+  // Initialized as here to avoid const_casts for the text pointers
+  TCamVideoQualityData data =
+    {
+    // TVideoQualitySettings:  
+      { 
+      0,                                          // iQualityLevel - defined later
+      KCamVideoSizes[resIndex].iCamVideoRes,      // iVideoResolution 
+      aSet.iVideoFrameRate,                       // iVideoFrameRate  
+      aSet.iVideoBitRate,                         // iVideoBitRate   
+      aSet.iAudioBitRate,                         // iAudioBitRate    
+      AllocString8L( aSet.iVideoFileMimeType ),   // iVideoMimeType   
+      AllocString16L( aSet.iPreferredSupplier ),  // iPreferredSupplier
+      AllocString8L( aSet.iVideoCodecMimeType ),  // iVideoCodec      
+      AllocString8L( fourCCBuf ),                 // iAudioCodec
+      CamConfigurationUtility::VideoType( aSet.iVideoFileMimeType ), // iVideoFileType
+      ECamVideoClipMax                            // iVideoLength - changed later if necessary      
+      },
+      
+    KCamVideoSizes[resIndex].iCamVideoRes,        // iVideoResolution  
+    ECamVideoQualitySharing,                      // iQualitySetting - replaced later
+    descType,                                     // iDescription
+    KCamVideoIcons[descType],
+    KCamVideoTypeIcons[videoType]
+    };    
+        
+  PRINT( _L("Camera <= CCamConfiguration::CreateVideoQualityDataL" ) );   
+  return data;  
+  }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AppendVideoResIfSupportedL
+// ---------------------------------------------------------------------------
+// 
+void
+CCamConfiguration::AppendVideoResIfSupportedL( TInt aValue, RArray<TInt>&aArray ) const
+  {
+  TInt n( iVideoQualities.Count() );
+  for( TInt i=0; i<n; i++ )
+    {
+    if( iVideoQualities[i].iVideoResolution == aValue )
+      {
+      aArray.AppendL( aValue );  
+      }
+    }  
+  }  
+    
+// ---------------------------------------------------------------------------
+// CCamConfiguration::CMRAvgVideoBitRateScaler
+// ---------------------------------------------------------------------------
+//    
+TReal    
+CCamConfiguration::CMRAvgVideoBitRateScaler() const
+  {
+  return iCMRAvgVideoBitRateScaler;  
+  }
+    
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetRequiredImageQualityIndex
+// ---------------------------------------------------------------------------
+//
+TInt CCamConfiguration::GetRequiredImageQualityIndex( const TSize& aResolution ) const
+    {
+    TInt QualityIndex = 0;
+    TInt MaxCount = NumPrimaryImageQualities();
+    TCamImageQualityData QData;
+    for ( TInt i = 0; i < MaxCount; i++ )
+        {
+        QData = ImageQualityData( i );
+        if ( QData.iPhotoSize.iWidth == aResolution.iWidth
+             && QData.iPhotoSize.iHeight == aResolution.iHeight )
+            {
+            QualityIndex = i;
+            }
+        }
+    return QualityIndex;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto
+// ---------------------------------------------------------------------------
+//
+TSize CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto( const TSize& aRequiredResolution ) const {
+	PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto aRequiredResolution: (%d,%d)"), aRequiredResolution.iWidth, aRequiredResolution.iHeight );
+    TInt MaxCount = NumPrimaryImageQualities();
+    TCamImageQualityData QData;
+    TSize Reso( 0, 0 );
+    TBool found = EFalse;
+    for ( TInt i = 0; i < MaxCount; i++ )
+        {
+        QData = ImageQualityData( i );
+        PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto index: %d PhotoSize: (%d,%d)"), i,QData.iPhotoSize.iWidth, QData.iPhotoSize.iHeight );
+        if ( QData.iPhotoSize.iWidth == aRequiredResolution.iWidth
+             && QData.iPhotoSize.iHeight == aRequiredResolution.iHeight )
+            {
+                Reso = aRequiredResolution;
+                found = ETrue;
+            }
+        }
+    if ( !found && aRequiredResolution != TSize(0,0) ) { // TSize(0,0) should be returned the same as it means the mms quality
+        TInt referenceQuality = aRequiredResolution.iWidth*aRequiredResolution.iHeight;
+        TInt currentQuality = 0;
+        TInt closestMatch = Abs(referenceQuality-currentQuality);
+        PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto closestMatch: (%d)"), closestMatch );
+        TInt currentMatch = 0;
+        for ( TInt i = 0; i < MaxCount; i++ )
+            {
+            QData = ImageQualityData( i );
+            PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto index: %d PhotoSize: (%d,%d)"), i, QData.iPhotoSize.iWidth, QData.iPhotoSize.iHeight );
+            currentQuality = QData.iPhotoSize.iWidth*QData.iPhotoSize.iHeight;
+            currentMatch = Abs(referenceQuality-currentQuality);
+            PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto currentMatch: (%d)"), currentMatch );
+            if ( currentMatch < closestMatch ) 
+                {
+                Reso.SetSize( QData.iPhotoSize.iWidth, QData.iPhotoSize.iHeight );
+                closestMatch = currentMatch;
+                }
+            }
+        }
+    PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto return resolution: (%d,%d)"), Reso.iWidth, Reso.iHeight );
+    return Reso;
+}
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetRequiredVideoQualityIndex
+// ---------------------------------------------------------------------------
+//
+TInt CCamConfiguration::GetRequiredVideoQualityIndex( const TSize& aResolution ) const
+    {
+    PRINT2(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex aResolution: (%d,%d)"), aResolution.iWidth, aResolution.iHeight );
+    TInt QualityIndex = 0;
+    TInt MaxCount = NumVideoQualities();
+    PRINT1(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex MaxCount: %d"), MaxCount );
+    TCamVideoQualityData QData;
+    TSize VideoResolution(0,0);
+    //for ( TInt i = 0; i < MaxCount; i++ )
+    for ( TInt i = MaxCount-1; i >= 0; i-- )
+        {
+        QData = iVideoQualities[i];
+        VideoResolution = CamConfigurationUtility::CamVideoResolution( QData.iVideoResolution );
+        PRINT3(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex index: %d VideoResolution: (%d,%d)"), i, VideoResolution.iWidth, VideoResolution.iHeight );
+        if ( VideoResolution.iWidth == aResolution.iWidth
+             && VideoResolution.iHeight == aResolution.iHeight )
+            {
+            QualityIndex = i;
+            }
+        }
+    PRINT1(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex return: %d"), QualityIndex );
+    return QualityIndex;
+    }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapRequiredResolutionToActualResolutionVideo
+// ---------------------------------------------------------------------------
+//
+TSize CCamConfiguration::MapRequiredResolutionToActualResolutionVideo( const TSize& aRequiredResolution ) const {
+    PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo aRequiredResolution: (%d,%d)"), aRequiredResolution.iWidth, aRequiredResolution.iHeight );
+    TInt MaxCount = NumVideoQualities();
+    TCamVideoQualityData QData;
+    TSize Reso( 0, 0 );
+    TBool found = EFalse;
+    TSize VideoResolution(0,0);
+    for ( TInt i = 0; i < MaxCount; i++ )
+        {
+        QData = iVideoQualities[i];
+        VideoResolution = CamConfigurationUtility::CamVideoResolution( QData.iVideoResolution );
+        PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo index: %d VideoResolution: (%d,%d)"), i, VideoResolution.iWidth, VideoResolution.iHeight );
+        if ( VideoResolution.iWidth == aRequiredResolution.iWidth
+             && VideoResolution.iHeight == aRequiredResolution.iHeight )
+            {
+                Reso = aRequiredResolution;
+                found = ETrue;
+            }
+        }
+    if ( !found && aRequiredResolution != TSize(0,0) ) { // TSize(0,0) should be returned the same as it means the mms quality
+        TInt referenceQuality = aRequiredResolution.iWidth*aRequiredResolution.iHeight;
+        TInt currentQuality = 0;
+        TInt closestMatch = Abs(referenceQuality-currentQuality);
+        PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo closestMatch: (%d)"), closestMatch );
+        TInt currentMatch = 0;
+        for ( TInt i = 0; i < MaxCount; i++ )
+            {
+            QData = iVideoQualities[i];
+            VideoResolution = CamConfigurationUtility::CamVideoResolution( QData.iVideoResolution );
+            PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo index: %d VideoResolution: (%d,%d)"), i, VideoResolution.iWidth, VideoResolution.iHeight );
+            currentQuality = VideoResolution.iWidth*VideoResolution.iHeight;
+            currentMatch = Abs(referenceQuality-currentQuality);
+            PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo currentMatch: (%d)"), currentMatch );
+            if ( currentMatch < closestMatch ) 
+                {
+                Reso.SetSize( VideoResolution.iWidth, VideoResolution.iHeight );
+                closestMatch = currentMatch;
+                }
+            }
+        }
+    PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo return resolution: (%d,%d)"), Reso.iWidth, Reso.iHeight );
+    return Reso;
+}
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetDefaultVideoQualityFromIcmL
+// ---------------------------------------------------------------------------
+//
+TCamVideoQualitySettings CCamConfiguration::GetDefaultVideoQualityFromIcmL()
+  {
+  PRINT(_L("Camera => CCamConfiguration::GetDefaultVideoQualityFromIcmL") );  
+  TInt totalLevels = iIcm->NumberOfVideoQualityLevels();
+  CArrayFixFlat<TUint>* levels 
+    = new (ELeave) CArrayFixFlat<TUint>( totalLevels );
+  CleanupStack::PushL( levels );
+  TVideoQualitySet set;
+  TVideoQualitySet temp;
+
+  if( iPrimaryCameraDisplayId )
+    {    
+    iIcm->GetVideoQualityLevelsL( *levels, iPrimaryCameraDisplayId );  
+    TInt numLevels( levels->Count() );
+    PRINT1(_L("Camera <> CCamConfiguration::GetDefaultVideoQualityFromIcmL - Total number of levels: %d"), numLevels );
+
+    iIcm->GetVideoQualitySet( set, levels->At( 0 ), iPrimaryCameraDisplayId );
+    
+    for( int i=1; i<numLevels; i++ )
+      {
+      iIcm->GetVideoQualitySet( temp, levels->At( i ), iPrimaryCameraDisplayId );
+	  if( temp.iCamcorderVisible > 0  && temp.iVideoQualitySetLevel > set.iVideoQualitySetLevel )
+        {      
+        set = temp;                 
+        }
+      }
+    }  
+  CleanupStack::PopAndDestroy( levels );
+
+  TInt count = iVideoQualities.Count();
+  TCamVideoQualityDescription descType 
+      = CamConfigurationUtility::VideoDescId( set.iCamcorderVisible ); 
+  for(TInt i = 0; i < count; i++)
+    {
+    if(iVideoQualities[i].iDescription == descType )
+      {
+      PRINT( _L("Camera <= CCamConfiguration::GetDefaultVideoQualityFromIcmL") );   
+	  return iVideoQualities[i].iQualitySetting;
+      }
+	 }
+
+  // In normal case application should not come to here
+  // If could not find the exact video qulity setting, just return WidescreenHigh
+  // Should be fixed in other product
+  return ECamVideoQualityNormalHigh; 
+  }
+
+// End of file  
+