1 /*

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Manages all settings data.*

    15 */

    16 

    17 

    18 // ===========================================================================

    19 // Includes

    20 #include <StringLoader.h>

    21 #include <barsread.h>

    22 #include <AknQueryDialog.h>

    23 #include <ecam.h>

    24 #include <data_caging_path_literals.hrh>  // KDC_APP_RESOURCE_DIR

    25 

    26 #include <cameraapp.rsg>

    27 #include <vgacamsettings.rsg>

    28 

    29 #include "CamSettingsModel.h"

    30 #include "CamPanic.h"

    31 #include "mcamsettingsmodelobserver.h"

    32 #include "CamAppUiBase.h"

    33 #include "CamSharedDataKeys.h"

    34 #include "CamUtility.h"

    35 #include "CamVideoQualityLevel.h"

    36 

    37 #include "CameraVariant.hrh" // Variant CR key values

    38 #include "CameraappPrivateCRKeys.h" // CR keys

    39 #include "camactivepalettehandler.h"

    40 #include "CamAppUi.h"

    41 #include "camsettingconversion.h"

    42 #include "camconfiguration.h"

    43 #include "CamStaticSettingsModel.h"

    44 #include "CameraUiConfigManager.h"

    45 

    46 // ===========================================================================

    47 // Constants

    48 

    49 const TInt KDynamicArrayGranularity  =  3;

    50 _LIT( KCamNhdResourceFileName, "z:nhdcamsettings.rss" );  

    51 _LIT( KCamVgaResourceFileName, "z:vgacamsettings.rss" );  

    52 

    53 

    54 // ===========================================================================

    55 // Local methods

    56 inline TBool SettingIdMatches( const TInt*        aSettingId, 

    57                                const TIntSetting& aSettingItem )

    58   {

    59   return (*aSettingId == aSettingItem.iItemId);

    60   };

    61 

    62 inline TInt FindIndex( const RPointerArray<TIntSetting>& aSettingArray,

    63                        const TInt&                       aSettingId    )

    64   {

    65   return aSettingArray.Find( aSettingId, SettingIdMatches );

    66   };

    67 

    68 inline TInt FindIndex( const RPointerArray<TIntSetting>& aSettingArray,

    69                        const TIntSetting&                aSettingItem  )

    70   {

    71   return FindIndex( aSettingArray, aSettingItem.iItemId );

    72   };

    73 

    74 

    75 // ===========================================================================

    76 // Class methods

    77 

    78 

    79 // ---------------------------------------------------------------------------

    80 // TCamVariantInfo constructor

    81 // ---------------------------------------------------------------------------

    82 //

    83 TCamVariantInfo::TCamVariantInfo() 

    84   : iFlags           ( -1 ),

    85     iTimeLapseSupport( ECamSupportUnknown ),

    86     iAlwaysOnSupport ( ECamSupportUnknown ),

    87     iVersion         ( -1, 0, 0           ) 

    88   {

    89   }

    90     

    91 // ===========================================================================

    92 

    93 // ---------------------------------------------------------------------------

    94 // CCamSettingsModel::NewL

    95 // Symbian OS two-phased constructor 

    96 // ---------------------------------------------------------------------------

    97 //

    98 CCamSettingsModel* CCamSettingsModel::NewL( CCamConfiguration& aConfiguration )

    99     {

   100     CCamSettingsModel* self = CCamSettingsModel::NewLC( aConfiguration );

   101     CleanupStack::Pop( self );

   102     return self;

   103     }

   104 

   105 // ---------------------------------------------------------------------------

   106 // CCamSettingsModel::NewLC

   107 // Symbian OS two-phased constructor

   108 // ---------------------------------------------------------------------------

   109 //

   110 CCamSettingsModel* CCamSettingsModel::NewLC( CCamConfiguration& aConfiguration )

   111     {

   112     CCamSettingsModel* self = new( ELeave ) CCamSettingsModel( aConfiguration );

   113     CleanupStack::PushL( self );

   114     self->ConstructL();

   115     return self;

   116     }

   117 

   118 // ---------------------------------------------------------------------------

   119 // CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL

   120 // Resets all user scene settings to their defaults without activating them.

   121 // ---------------------------------------------------------------------------

   122 //

   123 void CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL()

   124     {

   125     PRINT( _L("Camera => CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL"))		

   126 

   127     // Reset the user scene data in the repository

   128     iStaticModel->ResetSettingItem( KCamCrUserSceneBaseScene );

   129     iStaticModel->ResetSettingItem( KCamCrUserSceneWhiteBalance );

   130     iStaticModel->ResetSettingItem( KCamCrUserSceneColourFilter );

   131     iStaticModel->ResetSettingItem( KCamCrUserSceneFlash );

   132     iStaticModel->ResetSettingItem( KCamCrUserSceneExposure );

   133 

   134     if ( iUiConfigManager->IsISOSupported() )

   135         {

   136         iStaticModel->ResetSettingItem( KCamCrUserSceneLightSensitivity );

   137         }

   138     iStaticModel->ResetSettingItem( KCamCrUserSceneContrast );

   139     iStaticModel->ResetSettingItem( KCamCrUserSceneImageSharpness );

   140 

   141     // Reload the static user scene settings

   142     iUserSceneSettings.ResetAndDestroy();

   143     iStaticModel->ReadFromCenRepL(

   144                     static_cast<TInt>( ECamSettingItemUserSceneRangeMin ),

   145                     static_cast<TInt>( ECamSettingItemUserSceneRangeMax ),

   146                     iUserSceneSettings

   147                    );

   148     PRINT( _L("Camera <= CCamSettingsModel::ResetUserSceneWithoutActivatingChangesL"))		

   149     }

   150 

   151 // ---------------------------------------------------------------------------

   152 // CCamSettingsModel::ResetUserSceneL

   153 // Resets all user scene settings to their defaults.

   154 // ---------------------------------------------------------------------------

   155 //

   156 void CCamSettingsModel::ResetUserSceneL()

   157     {

   158     PRINT( _L("Camera => CCamSettingsModel::ResetUserSceneL"))	

   159     // Reset the user scene based on scene in the repository to get the default value

   160     ResetUserSceneWithoutActivatingChangesL();

   161     TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );

   162     // If current scene is user scene

   163     if ( ECamSceneUser == scene )

   164         {

   165         // if the user scene is currently the photo scene then

   166         // activate all the default scene settings to the AP

   167         ActivateUserSceneSettingsL();

   168         }

   169     PRINT( _L("Camera <= CCamSettingsModel::ResetUserSceneL"))	    

   170     }

   171 

   172 

   173 

   174 // ---------------------------------------------------------------------------

   175 // CCamSettingsModel::IntegerSettingValue

   176 // Returns the current integer value for the specified setting

   177 // ---------------------------------------------------------------------------

   178 //

   179 TInt 

   180 CCamSettingsModel::IntegerSettingValue( TInt aSettingItem ) const

   181   {

   182   PRINT2( _L("Camera => CCamSettingsModel::IntegerSettingValue, id:%d [%s]"), 

   183           aSettingItem,

   184           KCamSettingItemNames[aSettingItem] );

   185 

   186   TInt value = KErrNotFound;

   187   // If the requested item is the photo quality value, this must

   188   // be filtered based on the current scene.

   189   if ( aSettingItem == ECamSettingItemPhotoQuality )

   190     {

   191     value = CurrentPhotoQualityValue();

   192     }

   193   // If the requested item is the photo size, this must be filtered based on

   194   // the current scene

   195   else if ( aSettingItem == ECamSettingItemPhotoSize )

   196     {

   197     value = CurrentPhotoResolution();

   198     }

   199   // If the requested item is the photo compression level, this must

   200   // be filtered based on the current scene, and burst mode.

   201   else if ( aSettingItem == ECamSettingItemPhotoCompression )

   202     {

   203     value = CurrentPhotoCompression();

   204     }

   205   else

   206     {

   207     // If we have previews active, check first if requested

   208     // setting is found among them. Settings model must pretend

   209     // that the current value is the one set to preview.

   210     TInt previewIndex( FindIndex( iSettingPreviews, aSettingItem ) );

   211     if( KErrNotFound != previewIndex )

   212       {

   213       PRINT( _L("Camera <> Setting item value in previewed currently!") );

   214       value = iSettingPreviews[previewIndex]->iValueId;

   215       

   216       if (ECamSettingItemDynamicSelfTimer == aSettingItem)     		//If the current setting Item is selftimer  

   217         {

   218         TInt settingIndex = SearchInSettingsListFor( iDynamicPhotoIntSettings, aSettingItem );  

   219         value = iDynamicPhotoIntSettings[settingIndex]->iValueId;	//Get the actual selftime setting value but not preview value

   220         }

   221       }

   222     // Otherwise, if setting item is in the dynamic photo settings return it's value.

   223     else if( ECamSettingItemDynamicPhotoRangeMax > aSettingItem 

   224           && ECamSettingItemDynamicPhotoRangeMin < aSettingItem )

   225       {

   226       TInt settingIndex = SearchInSettingsListFor( iDynamicPhotoIntSettings, aSettingItem );

   227       value = iDynamicPhotoIntSettings[settingIndex]->iValueId;

   228       }

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

   230     else if( ECamSettingItemDynamicVideoRangeMax > aSettingItem 

   231           && ECamSettingItemDynamicVideoRangeMin < aSettingItem )

   232       {

   233       TInt settingIndex = SearchInSettingsListFor( iDynamicVideoIntSettings, aSettingItem );

   234       value = iDynamicVideoIntSettings[settingIndex]->iValueId;

   235       }

   236     // Otherwise, if setting item is in the user scene settings return it's value.

   237     else if( ECamSettingItemUserSceneRangeMax > aSettingItem 

   238           && ECamSettingItemUserSceneRangeMin < aSettingItem )

   239       {

   240       TInt settingIndex = SearchInSettingsListFor( iUserSceneSettings, aSettingItem );

   241       value = iUserSceneSettings[settingIndex]->iValueId;

   242       }

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

   244     else if( ECamSettingItemVideoClipLength == aSettingItem )

   245         {

   246         // Video clip length workaround

   247         // PRINT( _L("Camera <> ECamSettingItemVideoClipLength") );  

   248         TInt videoQuality = IntegerSettingValue( ECamSettingItemVideoQuality );

   249         value = iQualityLevels[videoQuality]->VideoLength();

   250         }

   251     else

   252         {

   253         value = iStaticModel->IntegerSettingValue( aSettingItem );

   254         }

   255     }

   256 

   257   PRINT1( _L("Camera <= CCamSettingsModel::IntegerSettingValue, value:%d"), value );

   258   return value;

   259   }

   260 

   261 

   262 

   263 

   264 // ---------------------------------------------------------------------------

   265 // CCamSettingsModel::SceneSettingValue

   266 // Returns the setting value for a specific field of a scene 

   267 // ---------------------------------------------------------------------------

   268 //

   269 TInt 

   270 CCamSettingsModel::SceneSettingValue( TInt aSceneId, 

   271                                       TInt aSceneField ) const

   272   {

   273   PRINT2( _L("CCamSettingsModel::SceneSettingValue, scene[%s] setting[%s]"), 

   274           KCamSceneNames[aSceneId],

   275           KCamSettingItemNames[aSceneField] );

   276 

   277   // If setting item is a scene in the photo scene list

   278   TInt sceneIndex = FindSceneInSceneList( aSceneId, iPhotoScenes );

   279   if ( sceneIndex != KErrNotFound )

   280     {

   281     // Search for the field in the scene's field list.

   282     const RPointerArray<TIntSetting>& sceneSettings = 

   283                                         iPhotoScenes[sceneIndex]->iSettings;

   284     TInt fieldCount = sceneSettings.Count();

   285     for ( TInt i = 0; i < fieldCount; ++i )

   286       {

   287       if ( sceneSettings[i]->iItemId == aSceneField )

   288         {

   289         return sceneSettings[i]->iValueId;

   290         }

   291       }

   292     }

   293 

   294   // Otherwise if setting item is a scene in the video scene list

   295   sceneIndex = FindSceneInSceneList( aSceneId, iVideoScenes );

   296   if ( sceneIndex != KErrNotFound )

   297     {

   298     // Search for the field in the scene's field list.

   299     const RPointerArray<TIntSetting>& sceneSettings = 

   300                                         iVideoScenes[sceneIndex]->iSettings;

   301     TInt fieldCount = sceneSettings.Count();

   302     for ( TInt i = 0; i < fieldCount; ++i )

   303       {

   304       if ( sceneSettings[i]->iItemId == aSceneField )

   305         {

   306         return sceneSettings[i]->iValueId;

   307         }

   308       }

   309     }

   310   

   311   else

   312     {

   313     PRINT( _L("Camera => CCamSettingsModel::ECamPanicUnknownSettingItem 3" ))

   314     CamPanic( ECamPanicUnknownSettingItem );

   315     }

   316   

   317   return sceneIndex;

   318   }

   319 

   320 // ---------------------------------------------------------------------------

   321 // CCamSettingsModel::SetIntegerSettingValueL

   322 // Sets a new integer value for the specified setting

   323 // ---------------------------------------------------------------------------

   324 //

   325 void 

   326 CCamSettingsModel::SetIntegerSettingValueL( TInt aSettingItem, 

   327                                             TInt aSettingValue )

   328   {

   329   PRINT ( _L("Camera => CCamSettingsModel::SetIntegerSettingValueL") );

   330   CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( iEnv->AppUi() );

   331   TCamSettingItemIds settingId( 

   332       static_cast<TCamSettingItemIds>(aSettingItem) );

   333 

   334   PRINT2( _L("Camera <> Setting item[%s] value:%d"), KCamSettingItemNames[settingId], aSettingValue );

   335 

   336   // -------------------------------------------------------

   337   // Dynamic image settings

   338   if( ECamSettingItemDynamicPhotoRangeMin < settingId

   339    && ECamSettingItemDynamicPhotoRangeMax > settingId )

   340     {

   341     TInt settingIndex = SearchInSettingsListFor( iDynamicPhotoIntSettings, 

   342                                                  settingId );

   343     iDynamicPhotoIntSettings[settingIndex]->iValueId = aSettingValue;

   344     

   345     // Changing scene

   346     if ( ECamSettingItemDynamicPhotoScene == settingId )

   347       {

   348        if ( ECamActiveCameraNone != appUi->ActiveCamera() || ( ECamActiveCameraNone == appUi->ActiveCamera() && ECamSceneAuto == aSettingValue ) )

   349            {

   350            PhotoSceneHasChangedL( aSettingValue );

   351            }

   352       }

   353     }

   354   // -------------------------------------------------------

   355   // Dynamic video settings

   356   else if( ECamSettingItemDynamicVideoRangeMin < settingId

   357         && ECamSettingItemDynamicVideoRangeMax > settingId )

   358     {

   359     TInt settingIndex = SearchInSettingsListFor( iDynamicVideoIntSettings, 

   360                                                  settingId );

   361     iDynamicVideoIntSettings[settingIndex]->iValueId = aSettingValue;

   362     if ( settingId == ECamSettingItemDynamicVideoScene )

   363       {

   364       VideoSceneHasChangedL( aSettingValue );

   365       }

   366     }

   367   // -------------------------------------------------------

   368   // User scene settings

   369   else if( ECamSettingItemUserSceneRangeMin < settingId

   370         && ECamSettingItemUserSceneRangeMax > settingId )

   371     {

   372     TBool userSceneModeSettingChanged = EFalse;

   373     // If the based-on scene has changed

   374     if ( settingId == ECamSettingItemUserSceneBasedOnScene )

   375       {

   376       TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );

   377       // If current scene is user scene

   378       if ( ECamSceneUser == scene )

   379         {

   380         // Handle other changes to the settings required by the change in scene.

   381         UserSceneHasChangedL( aSettingValue, ETrue );

   382         }

   383       // Otherwise the user scene hasn't been selected as the active scene

   384       // - the change option has just been selected in the scene setting list

   385       else 

   386         {

   387         // just handle a change in the scene

   388         UserSceneHasChangedL( aSettingValue, EFalse );

   389         }

   390       userSceneModeSettingChanged = ETrue;

   391       }

   392     // Writing values to CenRep for all the settings.

   393     TInt settingIndex = SearchInSettingsListFor( iUserSceneSettings, settingId );

   394     iUserSceneSettings[settingIndex]->iValueId = aSettingValue;

   395     SaveStaticSettingL( settingId );

   396     

   397     // If there is only one setting changed other than scene mode setting 

   398     // and if the Dynamic Scene mode is "User Scene" we update the new setting

   399     // value to the camera dynamic settings

   400     if ( !userSceneModeSettingChanged )

   401       {

   402       TInt scene = IntegerSettingValue( ECamSettingItemDynamicPhotoScene );

   403       // If user scene is the currently active photo scene then activate the

   404       // new user scene settings.

   405       if ( ECamSceneUser == scene )

   406         {

   407         CopyUserSceneSettingToCaptureSettingL( settingId );

   408         }

   409       }

   410     

   411     }

   412   // -------------------------------------------------------

   413   else

   414     {

   415     // use the static settings model

   416     iStaticModel->SetIntegerSettingValueL( aSettingItem, aSettingValue );

   417     }

   418   // -------------------------------------------------------

   419  

   420   NotifyObservers( settingId, aSettingValue ); 

   421 

   422   PRINT ( _L("Camera <= CCamSettingsModel::SetIntegerSettingValueL") );

   423   }

   424 

   425 

   426 // ---------------------------------------------------------------------------

   427 // CCamSettingsModel::SetTextSettingValueL

   428 // Sets a new text value for the specified setting

   429 // ---------------------------------------------------------------------------

   430 //

   431 void CCamSettingsModel::SetTextSettingValueL( TInt aSettingItem,

   432                                               const TDesC& aSettingValue )

   433     {

   434     iStaticModel->SetTextSettingValueL( aSettingItem, aSettingValue );

   435     NotifyObservers( (TCamSettingItemIds)aSettingItem, aSettingValue );

   436     }

   437 

   438 

   439 // ---------------------------------------------------------------------------

   440 // CCamSettingsModel::TextSettingValue

   441 // Returns the current text value for the specified setting

   442 // ---------------------------------------------------------------------------

   443 //

   444 TPtrC 

   445 CCamSettingsModel::TextSettingValue( TInt aSettingItem ) const

   446   {

   447   return iStaticModel->TextSettingValue( aSettingItem );

   448   }

   449 

   450 // ---------------------------------------------------------------------------

   451 // CCamSettingsModel::SettingValueEnabled

   452 // Returns ETrue if the setting value is currently enabled

   453 // ---------------------------------------------------------------------------

   454 //

   455 TBool CCamSettingsModel::SettingValueEnabled( TInt aSettingItem, 

   456                                              TInt aSettingValue ) const

   457     {

   458     TCamImageQualitySetting maxPhoto = static_cast<TCamImageQualitySetting>( iPhotoQualityLevels[iPhotoQualityLevels.Count() - 1].iPhotoResolution );

   459     // If the setting value is maximum photo size, and the current

   460     // scene is sports, then this setting value is disabled

   461     if ( ( aSettingItem == ECamSettingItemPhotoQuality ) && 

   462          ( aSettingValue == maxPhoto ) )

   463         {

   464         // If the current scene is sports, disable the option

   465         TCamSceneId scene = static_cast< TCamSceneId >

   466                ( IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) );

   467         if ( scene == ECamSceneSports )

   468             {

   469             return EFalse;

   470             }

   471         // Otherwise, if the current scene is the user scene and

   472         // it is based on the 'Sports' scene then disable the option.

   473         else if ( scene == ECamSceneUser ) 

   474             {

   475             // ...Get the based on scene.

   476             TCamSceneId baseScene = static_cast< TCamSceneId >

   477                 ( IntegerSettingValue( ECamSettingItemUserSceneBasedOnScene ) );

   478             if ( baseScene == ECamSceneSports )

   479                 {

   480                 return EFalse;

   481                 }

   482             }

   483         else

   484             {

   485             // Otherwise, the option is enabled

   486             return ETrue;

   487             }       

   488         }

   489     // The high quality video setting is not supported if

   490     // the second camera is enabled

   491     else if ( aSettingItem == ECamSettingItemVideoQuality && 

   492               aSettingValue == ECamVideoQualityHigh &&

   493               static_cast<CCamAppUiBase*>( 

   494                     iEnv->AppUi() )->IsSecondCameraEnabled() )

   495         {

   496         return EFalse;

   497         }

   498     // All other setting item values are allowed

   499     else 

   500         {

   501         return ETrue;

   502         }

   503 

   504     return ETrue;

   505     }

   506 

   507 

   508 

   509 // ---------------------------------------------------------------------------

   510 //

   511 // ---------------------------------------------------------------------------

   512 //

   513 void 

   514 CCamSettingsModel

   515 ::AttachObserverL( const MCamSettingsModelObserver* aObserver )

   516   {

   517   if( aObserver )

   518     {

   519     TInt index = iObservers.Find( aObserver );

   520     if( KErrNotFound == index )

   521       {

   522       iObservers.AppendL( aObserver );

   523       }

   524     }

   525   }

   526 

   527 

   528 // ---------------------------------------------------------------------------

   529 //

   530 // ---------------------------------------------------------------------------

   531 //

   532 void

   533 CCamSettingsModel

   534 ::DetachObserver( const MCamSettingsModelObserver* aObserver )

   535   {

   536   if( aObserver )

   537     {

   538     TInt index = iObservers.Find( aObserver );

   539     if( KErrNotFound != index )

   540       {

   541       iObservers.Remove( index );

   542       }

   543     }

   544   }

   545 

   546 

   547 

   548 // ---------------------------------------------------------------------------

   549 // CCamSettingsModel::LoadSettingsL

   550 // Loads the settings from shared data, or if unable to from the resource file. 

   551 // ---------------------------------------------------------------------------

   552 //

   553 void 

   554 CCamSettingsModel::LoadSettingsL()   

   555   {

   556   PRINT( _L("Camera => CCamSettingsModel::LoadSettingsL"))

   557   // Remove any previously loaded values.

   558   UnloadSettings();

   559   

   560   PRINT( _L("Camera => CCamSettingsModel::LoadSettingsL B"))

   561   LoadDynamicSettingsL( R_CAM_PHOTO_DYNAMIC_SETTINGS_DATA, 

   562                         iDynamicPhotoIntSettings, 

   563                         iDynamicPhotoIntDefaults );

   564     

   565   PRINT( _L("Camera => CCamSettingsModel::LoadSettingsL C"))

   566   LoadDynamicSettingsL( R_CAM_VIDEO_DYNAMIC_SETTINGS_DATA, 

   567                         iDynamicVideoIntSettings, 

   568                         iDynamicVideoIntDefaults );

   569   

   570   PRINT( _L("Camera => CCamSettingsModel::LoadSettingsL D"))

   571   // Load image scene data

   572   LoadSceneDataL();

   573 

   574   // Load video scene data

   575   LoadSceneDataL( EFalse );

   576   

   577   PRINT( _L("Camera => CCamSettingsModel::LoadSettingsL E"))

   578   //LoadScenesDataL( R_CAM_VIDEO_SCENES_DATA, iVideoScenes );

   579   

   580   PRINT( _L("Camera <= CCamSettingsModel::LoadSettingsL"))

   581   }

   582     

   583 

   584 

   585 

   586 // ---------------------------------------------------------------------------

   587 // DynamicSettingDefaultValue

   588 //

   589 // ---------------------------------------------------------------------------

   590 //

   591 TInt 

   592 CCamSettingsModel::DynamicSettingDefaultValue( TInt aSettingId ) const

   593   {

   594   TInt value = KErrNotFound;

   595 

   596   TInt index = SearchInSettingsListFor( iDynamicPhotoIntSettings, aSettingId );

   597   if( KErrNotFound != index )

   598     {

   599   	value = iDynamicPhotoIntDefaults[index];

   600     }

   601   index = SearchInSettingsListFor( iDynamicVideoIntSettings, aSettingId );

   602   if( KErrNotFound != index )

   603     {

   604   	value = iDynamicVideoIntDefaults[index];

   605     }    

   606 

   607   return value;

   608   }

   609 

   610 // ---------------------------------------------------------------------------

   611 // CCamSettingsModel::SetDynamicSettingsToDefaults

   612 // Sets all dynamic settings to their defaults. 

   613 // ---------------------------------------------------------------------------

   614 //

   615 void CCamSettingsModel::SetDynamicSettingsToDefaults()

   616     {

   617     // Set photo dynamic settings to their defaults.

   618     TInt i;

   619     TInt settingsListCount = iDynamicPhotoIntSettings.Count();

   620     for ( i = 0; i < settingsListCount; ++i )

   621         {

   622         iDynamicPhotoIntSettings[i]->iValueId = iDynamicPhotoIntDefaults[i];

   623         }

   624     // Set video dynamic settings to their defaults.

   625     settingsListCount = iDynamicVideoIntSettings.Count();

   626     for ( i = 0; i < settingsListCount; ++i )

   627         {

   628         iDynamicVideoIntSettings[i]->iValueId = iDynamicVideoIntDefaults[i];

   629         }

   630     }

   631 

   632 // ---------------------------------------------------------------------------

   633 // CCamSettingsModel::SetDynamicSettingsToDefault

   634 // Sets a dynamic setting to its default. 

   635 // ---------------------------------------------------------------------------

   636 //

   637 void CCamSettingsModel::SetDynamicSettingToDefault( TInt aSettingItem )

   638     {

   639     // Set photo dynamic settings to their defaults.

   640     TInt i;

   641     TBool found = EFalse;

   642     TInt settingsListCount = iDynamicPhotoIntSettings.Count();

   643     for ( i = 0; i < settingsListCount && !found; ++i )

   644         {

   645         if ( aSettingItem == iDynamicPhotoIntSettings[i]->iItemId )

   646             {

   647             iDynamicPhotoIntSettings[i]->iValueId = iDynamicPhotoIntDefaults[i];

   648             found = ETrue;

   649             }

   650         }

   651     // Set video dynamic settings to their defaults.

   652     settingsListCount = iDynamicVideoIntSettings.Count();

   653     for ( i = 0; i < settingsListCount && !found; ++i )

   654         {

   655         if ( aSettingItem == iDynamicVideoIntSettings[i]->iItemId )

   656             {

   657             iDynamicVideoIntSettings[i]->iValueId = iDynamicVideoIntDefaults[i];

   658             found = ETrue;

   659             }

   660         }

   661 

   662     // NB no error is reported is it's not found

   663     }

   664 

   665 

   666 // ---------------------------------------------------------------------------

   667 // virtual SetDynamicSettingToSceneDefaultL

   668 //

   669 // Sets a dynamic setting to scene default. 

   670 // ---------------------------------------------------------------------------

   671 //

   672 TInt

   673 CCamSettingsModel::SetDynamicSettingToSceneDefaultL( TInt  aSceneId,

   674                                                      TInt  aSceneField,

   675                                                      TInt  aSettingId,

   676                                                      TBool aVideoScene )

   677   {

   678   PRINT( _L("Camera => CCamSettingsModel::SetDynamicSettingToSceneDefault") );

   679 

   680   RPointerArray<TIntSetting>* sceneSettings = NULL;

   681   TInt                        sceneIndex    = KErrNotFound;

   682 

   683   if( !aVideoScene )

   684     { 

   685     sceneIndex = FindSceneInSceneList( aSceneId, iPhotoScenes );

   686     if( KErrNotFound != sceneIndex )

   687       {

   688       sceneSettings = &(iPhotoScenes[sceneIndex]->iSettings);

   689       }

   690     }

   691   else

   692     {

   693     sceneIndex = FindSceneInSceneList( aSceneId, iVideoScenes );

   694     if( KErrNotFound != sceneIndex )

   695       {

   696       sceneSettings = &(iVideoScenes[sceneIndex]->iSettings);

   697       }

   698     }

   699  

   700   TInt settingIndex = KErrNotFound;

   701   if( sceneSettings )

   702     {

   703     settingIndex = SearchInSettingsListFor( *sceneSettings, aSceneField );

   704     if( settingIndex != KErrNotFound )

   705       {

   706       SetIntegerSettingValueL( aSettingId, 

   707                               (*sceneSettings)[settingIndex]->iValueId );

   708       }

   709     }

   710 

   711   PRINT( _L("Camera <= CCamSettingsModel::SetDynamicSettingToSceneDefault") );

   712   return settingIndex;

   713   }

   714 

   715 

   716 

   717 // ---------------------------------------------------------------------------

   718 // CCamSettingsModel::LoadStaticSettingsL

   719 // Loads the static settings from shared data. Required to update

   720 // the settings whenever get foreground event, incase of external

   721 // changes to the settings.

   722 // Note that static settings cannot be loaded until the AppUi has been created,

   723 // as which settings to use is dependent on if app is embedded or not.

   724 // ---------------------------------------------------------------------------

   725 //

   726 void CCamSettingsModel::LoadStaticSettingsL( TBool aIsEmbedded )

   727     {

   728     PRINT(_L("Camera => CCamSettingsModel::LoadStaticSettingsL" ))

   729     iEmbedded = aIsEmbedded;

   730 

   731     // The model needs to register as an observer of changes in burst mode

   732     // activation, as burst mode limits some settings values.

   733     // The model registers with the AppUi which is created after the model.

   734     // Registration is done here so we can guarantee that the AppUi has 

   735     // been created.

   736     CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>

   737                                             ( iEnv->AppUi() );

   738     appUi->AddBurstModeObserverL(  this );

   739 

   740     // Free all memory currently used by the static settings.

   741     UnloadStaticSettings();

   742     

   743     iStaticModel->ReadFromCenRepL(

   744                     static_cast<TInt>( ECamSettingItemUserSceneRangeMin ),

   745                     static_cast<TInt>( ECamSettingItemUserSceneRangeMax ),

   746                     iUserSceneSettings

   747                    );

   748     iStaticModel->LoadStaticSettingsL( aIsEmbedded );

   749 

   750     PRINT(_L("Camera <= CCamSettingsModel::LoadStaticSettingsL" ))

   751 

   752     }

   753 

   754 

   755 // ---------------------------------------------------------------------------

   756 // CCamSettingsModel::SaveSettingsL

   757 // Saves the static settings to the shared data ini file

   758 // ---------------------------------------------------------------------------

   759 //

   760 void CCamSettingsModel::SaveSettingsL() 

   761   {

   762   // This method is removed as we save to the CenRep whenever some setting

   763   // is changed directly .. refer to SaveStaticSettingsL method

   764   }

   765 

   766 

   767 // ---------------------------------------------------------------------------

   768 // 

   769 // ---------------------------------------------------------------------------

   770 //

   771 void

   772 CCamSettingsModel::SaveStaticSettingL( TCamSettingItemIds aSettingId )

   773   {

   774   PRINT1( _L("Camera => CCamSettingsModel::SaveStaticSettingL, setting:[%s]"), 

   775           KCamSettingItemNames[aSettingId] );

   776   TBool callStaticModel = ETrue;

   777   

   778     {

   779     // All the User Specific Settings are saved here in the CenRep

   780     // and the remaining static settings are handled in the static model

   781     RPointerArray<TIntSetting>* settingArray = 

   782           MapSettingItem2SettingsList( aSettingId );

   783 

   784     if( settingArray == &iUserSceneSettings )

   785         {

   786         callStaticModel = EFalse;

   787         TUint32 crKey = CCamStaticSettingsModel::MapSettingItem2CRKey( aSettingId, iEmbedded );

   788         iStaticModel->SaveCenRepItemL( aSettingId, crKey, *settingArray );

   789         }

   790     }

   791   if ( callStaticModel )

   792     {

   793     iStaticModel->SaveStaticSettingL( aSettingId );

   794     }

   795   PRINT( _L("Camera <= CCamSettingsModel::SaveStaticSettingL") ); 

   796   }

   797 

   798 

   799 // ---------------------------------------------------------------------------

   800 //

   801 // ---------------------------------------------------------------------------

   802 //

   803 RPointerArray<TIntSetting>*

   804 CCamSettingsModel::MapSettingItem2SettingsList( TCamSettingItemIds aSettingId )

   805   {

   806   PRINT( _L("Camera => CCamSettingsModel::MapSettingItem2SettingsList") );

   807 

   808   RPointerArray<TIntSetting>* array( NULL );

   809 

   810   if( ECamSettingItemUserSceneRangeMin < aSettingId

   811         && ECamSettingItemUserSceneRangeMax > aSettingId )

   812     {

   813     array = &iUserSceneSettings;

   814     }

   815   else if( ECamSettingItemDynamicPhotoRangeMin < aSettingId

   816         && ECamSettingItemDynamicPhotoRangeMax > aSettingId )

   817     {

   818     array = &iDynamicPhotoIntSettings;

   819     }

   820   else if( ECamSettingItemDynamicVideoRangeMin < aSettingId

   821         && ECamSettingItemDynamicVideoRangeMax > aSettingId )

   822     {

   823     array = &iDynamicVideoIntSettings;

   824     }

   825   else

   826     {

   827     array = iStaticModel->MapSettingItem2SettingsList( aSettingId );

   828     }

   829 

   830   PRINT( _L("Camera <= CCamSettingsModel::MapSettingItem2SettingsList") );

   831   return array;

   832   }

   833 

   834 

   835 // ---------------------------------------------------------------------------

   836 // CCamSettingsModel::~CCamSettingsModel

   837 // Destructor

   838 // ---------------------------------------------------------------------------

   839 //

   840 CCamSettingsModel::~CCamSettingsModel()

   841   {

   842   PRINT( _L("Camera => ~CCamSettingsModel") );

   843 

   844   UnLoadResources(); 

   845 

   846   iObservers.Reset();

   847   iObservers.Close();

   848 

   849   iSettingPreviews.ResetAndDestroy();

   850   iSettingPreviews.Close();

   851 

   852  

   853   iUserSceneSettings.ResetAndDestroy();

   854   iUserSceneSettings.Close();

   855   

   856   iUserSceneSettingsBackup.ResetAndDestroy();

   857   iUserSceneSettingsBackup.Close();

   858   

   859   iDynamicPhotoIntSettings.ResetAndDestroy();

   860   iDynamicPhotoIntSettings.Close();

   861   

   862   iDynamicPhotoIntSettingsBackup.ResetAndDestroy();

   863   iDynamicPhotoIntSettingsBackup.Close();

   864   

   865   iDynamicPhotoIntDefaults.Close();

   866   

   867   iDynamicVideoIntSettings.ResetAndDestroy();

   868   iDynamicVideoIntSettings.Close();

   869   

   870   iDynamicVideoIntSettingsBackup.ResetAndDestroy();

   871   iDynamicVideoIntSettingsBackup.Close();

   872     

   873   iDynamicVideoIntDefaults.Close();

   874 

   875   iPhotoScenes.ResetAndDestroy();

   876   iPhotoScenes.Close();

   877   

   878   iVideoScenes.ResetAndDestroy();

   879   iVideoScenes.Close();

   880   

   881   iQualityLevels.ResetAndDestroy();

   882   iQualityLevels.Close();

   883   

   884   iVideoResolutions.Close();

   885   iPhotoQualityLevels.Close();

   886   iPhotoResolutions.Close();

   887   

   888   if ( iStaticModel )

   889     {

   890     delete iStaticModel;

   891     iStaticModel = NULL;

   892     }

   893 

   894   PRINT( _L("Camera <= ~CCamSettingsModel") );

   895   }

   896   

   897 // ---------------------------------------------------------------------------

   898 // CCamSettingsModel::CCamSettingsModel

   899 // C++ constructor

   900 // ---------------------------------------------------------------------------

   901 //

   902 CCamSettingsModel::CCamSettingsModel( CCamConfiguration& aConfiguration ) 

   903   : iDynamicPhotoIntDefaults( KDynamicArrayGranularity ), 

   904   	iDynamicVideoIntDefaults( KDynamicArrayGranularity ), 

   905   	iEngineReadyForVideoPrepare( ETrue ), 

   906   	iConfiguration( aConfiguration )

   907     {

   908     PRINT( _L("Camera => CCamSettingsModel::CCamSettingsModel") );  

   909 

   910     // set up secondary camera defaults

   911     // these values are not stored in the shared data file because

   912     // they do not persist when the camera is changed or the app is closed

   913 

   914     iSecondaryCameraSettings.iVideoQuality 

   915     = iConfiguration.SecondaryCameraVideoQuality();

   916     iSecondaryCameraSettings.iPhotoQuality 

   917     = iConfiguration.SecondaryCameraImageQuality();

   918 

   919     // Check that configuration can provide us secondary camera qualities

   920     // If either of them is unavailable, all we can do is panic

   921     PRINT( _L("Camera <> Checking secondary camera qualities") );  

   922     __ASSERT_ALWAYS( iSecondaryCameraSettings.iVideoQuality > 0, 

   923             CamPanic( ECamPanicSecondaryQualityMissing ) );

   924 

   925     __ASSERT_ALWAYS( iSecondaryCameraSettings.iPhotoQuality > 0, 

   926             CamPanic( ECamPanicSecondaryQualityMissing ) );

   927 

   928     // Check that configuration can provide us a MMS quality.

   929     // If not available, all we can do is panic. MMS quality is

   930     // needed in embedded mode.

   931     PRINT( _L("Camera <> Checking MMS quality") ); 

   932     __ASSERT_ALWAYS( iConfiguration.MmsImageQuality() > 0, 

   933                       CamPanic( ECamPanicMMSQualityMissing ) ); 

   934                       

   935                       

   936     PRINT( _L("Camera <= CCamSettingsModel::CCamSettingsModel") );                        

   937     }

   938 

   939 

   940 

   941 // ---------------------------------------------------------------------------

   942 // CCamSettingsModel::ConstructL

   943 // Symbian OS 2nd phase constructor

   944 // ---------------------------------------------------------------------------

   945 //

   946 void CCamSettingsModel::ConstructL()

   947     {

   948     PRINT( _L("Camera => CCamSettingsModel::ConstructL"))

   949     // Create reference to the CEikonEnv object, since it is used alot.

   950     iEnv = CEikonEnv::Static();

   951 

   952     LoadResourcesL(); 

   953                 

   954     iStaticModel = CCamStaticSettingsModel::NewL( iConfiguration );

   955     

   956     iUiConfigManager = iStaticModel->UiConfigManagerPtr();

   957     

   958     if ( !iUiConfigManager )CamPanic( ECamPanicNullPointer );

   959     

   960     PRINT( _L("Camera => CCamSettingsModel::ConstructL create respository"))

   961 

   962     // Load settings.

   963     LoadSettingsL();

   964 

   965     // Load the variant flags from the ini file

   966     ReadVariantFlagsL();

   967     

   968     // Load flag that specifies whether the engine should be updated with

   969     // settings after an engine Prepare..() call.

   970     // Create resource reader for reading photo static settings

   971     TResourceReader reader;

   972     iEnv->CreateResourceReaderLC( reader, R_CAM_ENGINE_UPDATE );

   973     iUpdateAfterPrepare = reader.ReadInt16();   

   974     // Pop resource reader.

   975     CleanupStack::PopAndDestroy();  

   976 

   977     // read in video quality levels

   978     TInt i;

   979     

   980     const TInt nVidQualities( iConfiguration.NumVideoQualities() );

   981     for ( i=0; i < nVidQualities; i++ )

   982         {

   983         TVideoQualitySettings set = iConfiguration.VideoQuality( i );

   984         CCamVideoQualityLevel* lev = CCamVideoQualityLevel::NewL( set );

   985         CleanupStack::PushL( lev );

   986         User::LeaveIfError( iQualityLevels.Append( lev ) );

   987         CleanupStack::Pop( lev );

   988         }                

   989 

   990     // read in (supported) video resolutions

   991     TResourceReader videoResReader;

   992     iEnv->CreateResourceReaderLC( videoResReader, R_CAM_VIDEO_RESOLUTION_ARRAY );

   993     

   994     // get array of supported values

   995     RArray<TInt> supportedVideoRes;

   996     CleanupClosePushL( supportedVideoRes );

   997     iConfiguration.GetPsiIntArrayL( ECamPsiSupportedVideoResolutions, supportedVideoRes );

   998 

   999     TInt numLevels = videoResReader.ReadInt16();

  1000 

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

  1002         {

  1003         TSize videoRes;

  1004         videoRes.iWidth = videoResReader.ReadInt16();

  1005         videoRes.iHeight = videoResReader.ReadInt16();

  1006 

  1007         User::LeaveIfError( iVideoResolutions.Append( videoRes ) );   

  1008         }

  1009         

  1010     // Close array of support vid resolutions

  1011     CleanupStack::PopAndDestroy( &supportedVideoRes );

  1012 

  1013     // Pop resource reader.

  1014     CleanupStack::PopAndDestroy();

  1015 

  1016 

  1017     const TInt numQualities( iConfiguration.NumImageQualities() );

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

  1019       {

  1020       User::LeaveIfError( 

  1021         iPhotoQualityLevels.Append( iConfiguration.ImageQuality( i ) ) );        

  1022       }      

  1023 

  1024     // read in photo resolutions

  1025     TResourceReader photoResReader;

  1026     iEnv->CreateResourceReaderLC( photoResReader, R_CAM_PHOTO_RESOLUTION_ARRAY );

  1027     numLevels = photoResReader.ReadInt16();

  1028 

  1029     // get array of supported values

  1030     RArray<TInt> supportedStillRes;

  1031     CleanupClosePushL( supportedStillRes );

  1032     

  1033     iConfiguration.GetPsiIntArrayL( ECamPsiSupportedStillResolutions, supportedStillRes ); 

  1034 

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

  1036         {

  1037         TSize photoRes;

  1038         photoRes.iWidth = photoResReader.ReadInt16();

  1039         photoRes.iHeight = photoResReader.ReadInt16();

  1040 

  1041         User::LeaveIfError( iPhotoResolutions.Append( photoRes ) );

  1042             

  1043         }        

  1044         

  1045     iPreviousFaceTrack = ECamSettOn;

  1046     iPreviousSceneMode = ECamSceneAuto;

  1047     // Close array of support photo resolutions

  1048     CleanupStack::PopAndDestroy( &supportedStillRes );

  1049         

  1050     // Pop resource reader.

  1051     CleanupStack::PopAndDestroy();

  1052     

  1053     PRINT( _L("Camera <= CCamSettingsModel::ConstructL"))

  1054     }

  1055 

  1056 

  1057 

  1058 

  1059 // ---------------------------------------------------------------------------

  1060 // NotifyObservers

  1061 //

  1062 // Notify setting model observers, that a setting item value has changed.

  1063 // Overload for integer setting items.

  1064 // ---------------------------------------------------------------------------

  1065 //

  1066 void 

  1067 CCamSettingsModel::NotifyObservers( TCamSettingItemIds aSettingId, 

  1068                                     TInt               aSettingValue )

  1069   {

  1070   PRINT1( _L("Camera => CCamSettingsModel::NotifyObservers, observers:%d"), iObservers.Count() );

  1071   for( TInt i = 0; i < iObservers.Count(); i++ )

  1072     {

  1073     TRAP_IGNORE( iObservers[i]->IntSettingChangedL( aSettingId, 

  1074                                                     aSettingValue ) );

  1075     } 

  1076   PRINT ( _L("Camera <= CCamSettingsModel::NotifyObservers") );

  1077   }

  1078 

  1079 // ---------------------------------------------------------------------------

  1080 // NotifyObservers

  1081 //

  1082 // Notify setting model observers, that a setting item value has changed.

  1083 // Overload for text setting items.

  1084 // ---------------------------------------------------------------------------

  1085 //

  1086 void 

  1087 CCamSettingsModel::NotifyObservers( TCamSettingItemIds aSettingId, 

  1088                                     const TDesC&       aSettingValue )

  1089   {

  1090   for( TInt i = 0; i < iObservers.Count(); i++ )

  1091     {

  1092     TRAP_IGNORE( iObservers[i]->TextSettingChangedL( aSettingId, 

  1093                                                      aSettingValue ) );

  1094     } 

  1095   }

  1096 

  1097 

  1098 // ---------------------------------------------------------------------------

  1099 // ReadVariantFlagsL

  1100 //

  1101 // Read Central Repository key values in KCRUidCameraappVariant repository.

  1102 // ---------------------------------------------------------------------------

  1103 //

  1104 void 

  1105 CCamSettingsModel::ReadVariantFlagsL()

  1106   {

  1107   TInt crValue( 0 );

  1108   CRepository* cr = CRepository::NewLC( KCRUidCameraappVariant );

  1109 

  1110   // Get variant info general flags

  1111   User::LeaveIfError( cr->Get( KCamCrVariantFlags, crValue ) );

  1112   iVariantInfo.iFlags = crValue;

  1113 

  1114   // Get 'time lapse enabled' flag

  1115   User::LeaveIfError( cr->Get( KCamCrTimeLapseSupport, crValue ) );

  1116 

  1117   iVariantInfo.iTimeLapseSupport = (KCamCrTimeLapseIsSupported == crValue)

  1118                                  ? ECamSupportOn

  1119                                  : ECamSupportOff;

  1120 

  1121   // Get 'app always running' flag

  1122   User::LeaveIfError( cr->Get( KCamCrAppAlwaysRunning, crValue ) );

  1123   iVariantInfo.iAlwaysOnSupport = (KCamCrAppAlwaysRunningIsOn == crValue)

  1124                                 ? ECamSupportOn

  1125                                 : ECamSupportOff;

  1126 

  1127 

  1128   // Get Public Release version

  1129   User::LeaveIfError( cr->Get( KCamCrVersionMajor, crValue ) );

  1130   iVariantInfo.iVersion.iMajor = (TInt8) crValue;

  1131 

  1132   User::LeaveIfError( cr->Get( KCamCrVersionMinor, crValue ) );

  1133   iVariantInfo.iVersion.iMinor = (TInt8) crValue;

  1134