camerauis/cameraapp/generic/src/cameracontroller/camconstantsettingprovider.cpp
changeset 19 d9aefe59d544
parent 3 8b2d6d0384b0
child 21 fa6d9f75d6a6
child 28 3075d9b614e6
equal deleted inserted replaced
3:8b2d6d0384b0 19:d9aefe59d544
     1 /*
       
     2 * Copyright (c) 2007 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:  CCamCameraControllerActive class implementation.
       
    15 *                
       
    16 *
       
    17 */
       
    18 
       
    19 #include "camcameracontrollerflags.hrh"
       
    20 
       
    21 #include <ecam.h>
       
    22 #ifdef CAMERAAPP_CAPI_V2
       
    23   #include <ecamadvsettings.h> // KECamFineResolutionFactor
       
    24 #endif
       
    25 
       
    26 #include "camlogging.h"
       
    27 #include "camcameracontroller.pan"
       
    28 #include "camcameracontrollertypes.h"
       
    29 #include "camconstantsettingprovider.h"
       
    30 #include "camsettingconversion.h"
       
    31 #include "CamAppController.h"
       
    32 #include "campointerutility.inl"
       
    33 
       
    34 using namespace NCamCameraController;
       
    35 
       
    36 // ===========================================================================
       
    37 // Local data
       
    38 
       
    39 static const CCamera::TFormat       KImageFormat            = CCamera::EFormatExif;
       
    40 static const TSize                  KImageSize              = TSize(1600,1200); // 2MPix, supported in most products
       
    41 static const TInt                   KImageFactor            = 100;
       
    42 
       
    43 static const CCamera::TFormat       KImageFormatSecondary   = CCamera::EFormatFbsBitmapColor16M;
       
    44 static const TSize                  KImageSizeSecondary     = TSize( 320,240 );
       
    45 static const TInt                   KImageFactorSecondary   = 100;
       
    46 
       
    47 static const TSize                  KViewfinderSize         = TSize(320, 240);
       
    48 static const TCamViewfinderMode     KViewFinderMode         = ECamViewfinderBitmap;
       
    49 
       
    50 static const TSize                  KViewfinderSizeSecondary   = TSize( 240, 180 );
       
    51 
       
    52 static const CCamera::TFormat       KSnapshotFormat         = CCamera::EFormatFbsBitmapColor16M;
       
    53 static const TSize                  KSnapshotSize           = TSize(320, 240);
       
    54 static const TBool                  KSnapshotMaintainAspect = EFalse;
       
    55 
       
    56 static const CCamera::TFlash        KFlashSetting           = CCamera::EFlashAuto;
       
    57 
       
    58 static const CCamera::TExposure     KEvModeSetting          = CCamera::EExposureAuto;
       
    59 #ifdef CAMERAAPP_CAPI_V2
       
    60   static const TInt                   KEvValueSetting       = 2;
       
    61 #endif
       
    62 
       
    63 static const TInt                   KISOValue               = 100;
       
    64 static const CCamera::TWhiteBalance KWbModeSetting          = CCamera::EWBAuto;
       
    65 static const CCamera::TBrightness   KBrightnessValue        = CCamera::EBrightnessAuto;
       
    66 static const CCamera::TContrast     KContrastValue          = CCamera::EContrastAuto;
       
    67 static const TInt                   KDigitalZoomValue       = 1;
       
    68 static const TInt                   KOpticalZoomValue       = 1;
       
    69 
       
    70 #ifdef CAMERAAPP_CAPI_V2
       
    71   static const CCamera::CCameraAdvancedSettings::TFocusRange KFocusRange = 
       
    72     CCamera::CCameraAdvancedSettings::EFocusRangeAuto;
       
    73 #endif // CAMERAAPP_CAPI_V2
       
    74 
       
    75 // -------------------------------------
       
    76 // Video by CAE settings:
       
    77 // - MMS video setting, as it's the same in all products in use.
       
    78 #ifdef CAMERAAPP_CAE_FOR_VIDEO
       
    79 
       
    80 static const TSize KVideoFrameSize                      = TSize(176, 144);
       
    81 static const TReal KVideoFrameRate                      = 15.0f;
       
    82 static const TInt  KVideoVideoBitRate                   = 64000;
       
    83 static const TInt  KVideoAudioBitRate                   = 12200;
       
    84 static const TBool KVideoAudioOn                        = ETrue;
       
    85 
       
    86 _LIT8( KVideoMimeType,  "video/3gpp"      );
       
    87 _LIT ( KVideoSupplier,  "Nokia"           );
       
    88 _LIT8( KVideoVideoType, "video/H263-2000" );
       
    89 _LIT8( KVideoAudioType, " AMR"            );
       
    90 
       
    91 #endif // CAMERAAPP_CAE_FOR_VIDEO
       
    92 // -------------------------------------
       
    93 
       
    94 
       
    95 // ===========================================================================
       
    96 // Local methods
       
    97 
       
    98 
       
    99 // ===========================================================================
       
   100 // Methods
       
   101 
       
   102 // static 
       
   103 CCamConstantSettingProvider* 
       
   104 CCamConstantSettingProvider::NewL( CCamAppController& aController )
       
   105   {
       
   106   CCamConstantSettingProvider* self = 
       
   107       CCamConstantSettingProvider::NewLC( aController );
       
   108   CleanupStack::Pop( self );
       
   109   return self;  
       
   110   }
       
   111 
       
   112 // static 
       
   113 CCamConstantSettingProvider* 
       
   114 CCamConstantSettingProvider::NewLC( CCamAppController& aController )
       
   115   {
       
   116   CCamConstantSettingProvider* self = 
       
   117       new (ELeave) CCamConstantSettingProvider( aController );
       
   118   CleanupStack::PushL( self );
       
   119   self->ConstructL();
       
   120   return self;  
       
   121   }
       
   122 
       
   123 // virtual 
       
   124 CCamConstantSettingProvider::~CCamConstantSettingProvider()
       
   125   {
       
   126   iPendingSettingChanges.Close();
       
   127   }
       
   128   
       
   129 // ===========================================================================
       
   130 // From MCamSettingProvider
       
   131 
       
   132 // ---------------------------------------------------------------------------
       
   133 // virtual 
       
   134 // ---------------------------------------------------------------------------
       
   135 //
       
   136 void 
       
   137 CCamConstantSettingProvider::ProvideCameraParamL( 
       
   138     const NCamCameraController::TCamCameraParamId& aParamId,
       
   139           TAny*                                    aParamData )
       
   140   {
       
   141   __ASSERT_DEBUG( aParamData, Panic( ECamNullPointer ) );
       
   142   switch( aParamId )
       
   143     {
       
   144     // -----------------------------------------------------------------------
       
   145     case ECameraParamImage:
       
   146       {
       
   147       TPckgBuf<TCamParamsImage>* ptr = 
       
   148           static_cast<TPckgBuf<TCamParamsImage>*>( aParamData );
       
   149       CheckNonNullL( ptr, KErrNotFound );
       
   150       TCamParamsImage& params( (*ptr)() ); 
       
   151       
       
   152       if( ECamActiveCameraPrimary == iController.ActiveCamera() )
       
   153         {                     
       
   154         // Primary camera parameters
       
   155         params.iFormat        = KImageFormat;
       
   156         params.iSize          = KImageSize;
       
   157         params.iQualityFactor = KImageFactor;
       
   158         }
       
   159       else
       
   160         {                     
       
   161         // Secondary camera parameters
       
   162         params.iFormat        = KImageFormatSecondary;
       
   163         params.iSize          = KImageSizeSecondary;
       
   164         params.iQualityFactor = KImageFactorSecondary;
       
   165         }                                    
       
   166       
       
   167       break;
       
   168       }
       
   169     // -----------------------------------------------------------------------
       
   170 #ifdef CAMERAAPP_CAE_FOR_VIDEO
       
   171     case ECameraParamVideoCae:
       
   172       {
       
   173       TPckgBuf<TCamParamsVideoCae>* ptr = 
       
   174           static_cast<TPckgBuf<TCamParamsVideoCae>*>( aParamData );
       
   175       CheckNonNullL( ptr, KErrNotFound );
       
   176 
       
   177       TCamParamsVideoCae& params( (*ptr)() ); 
       
   178 
       
   179       params.iFrameSize    = KVideoFrameSize;
       
   180       params.iFrameRate    = KVideoFrameRate;
       
   181       params.iVideoBitRate = KVideoVideoBitRate;
       
   182       params.iAudioBitRate = KVideoAudioBitRate;
       
   183       params.iAudioOn      = KVideoAudioOn;
       
   184       params.iMimeType.Set ( KVideoMimeType  );
       
   185       params.iSupplier.Set ( KVideoSupplier  );
       
   186       params.iVideoType.Set( KVideoVideoType );
       
   187       params.iAudioType.Set( KVideoAudioType );
       
   188 
       
   189       break;
       
   190       }
       
   191 #endif // CAMERAAPP_CAE_FOR_VIDEO
       
   192     // -----------------------------------------------------------------------
       
   193     case ECameraParamVfMode:
       
   194       {
       
   195       TPckgBuf<TCamViewfinderMode>* ptr = 
       
   196           static_cast<TPckgBuf<TCamViewfinderMode>*>( aParamData );
       
   197       CheckNonNullL( ptr, KErrNotFound );
       
   198       TCamViewfinderMode& params( (*ptr)() ); 
       
   199       params = KViewFinderMode;
       
   200       break;
       
   201       }
       
   202     // -----------------------------------------------------------------------
       
   203     case ECameraParamSnapshot: 
       
   204       {
       
   205       TPckgBuf<TCamParamsSnapshot>* ptr = 
       
   206           static_cast<TPckgBuf<TCamParamsSnapshot>*>( aParamData );
       
   207       CheckNonNullL( ptr, KErrNotFound );
       
   208       TCamParamsSnapshot& params( (*ptr)() ); 
       
   209 
       
   210       params.iSize           = KSnapshotSize;
       
   211       params.iFormat         = KSnapshotFormat;
       
   212       params.iMaintainAspect = KSnapshotMaintainAspect;
       
   213       break;
       
   214       }
       
   215     // -----------------------------------------------------------------------
       
   216     default:
       
   217       {
       
   218       User::Leave( KErrNotSupported );
       
   219       break;
       
   220       }
       
   221     // -----------------------------------------------------------------------
       
   222     }
       
   223   }
       
   224 
       
   225 // ---------------------------------------------------------------------------
       
   226 //
       
   227 // ---------------------------------------------------------------------------
       
   228 //
       
   229 void 
       
   230 CCamConstantSettingProvider::ProvideCameraSettingL( 
       
   231     const NCamCameraController::TCamCameraSettingId& aSettingId,
       
   232           TAny*                                      aSettingData )
       
   233   { 
       
   234   switch( aSettingId )
       
   235     {
       
   236     case ECameraSettingQualityFactor:
       
   237       {
       
   238       TInt* ptr = static_cast<TInt*>( aSettingData );
       
   239       CheckNonNullL( ptr, KErrNotFound );
       
   240       *ptr = KImageFactor;
       
   241       break;
       
   242       }
       
   243     case ECameraSettingFlash:
       
   244       {
       
   245       CCamera::TFlash* ptr = 
       
   246         static_cast<CCamera::TFlash*>( aSettingData );
       
   247       CheckNonNullL( ptr, KErrNotFound );
       
   248       *ptr = KFlashSetting;
       
   249       break;
       
   250       }
       
   251     case ECameraSettingExposure:
       
   252       {
       
   253       TPckgBuf<TCamSettingDataExposure>* ptr = 
       
   254         static_cast<TPckgBuf<TCamSettingDataExposure>*>( aSettingData );
       
   255       CheckNonNullL( ptr, KErrNotFound );
       
   256 
       
   257       TCamSettingDataExposure& evData( (*ptr)() );
       
   258       evData.iExposureMode = KEvModeSetting;
       
   259 #ifdef CAMERAAPP_CAPI_V2
       
   260       evData.iExposureStep = KEvValueSetting * KECamFineResolutionFactor;
       
   261 #else
       
   262       evData.iExposureStep = 0;
       
   263 #endif
       
   264       break;
       
   265       }
       
   266     case ECameraSettingLightSensitivity:
       
   267       {
       
   268       TInt* ptr = static_cast<TInt*>( aSettingData );
       
   269       CheckNonNullL( ptr, KErrNotFound );
       
   270       *ptr = KISOValue;
       
   271       break;
       
   272       }
       
   273     case ECameraSettingWhiteBalance:
       
   274       {
       
   275       TPckgBuf<TCamSettingDataWhiteBalance>* ptr = 
       
   276         static_cast<TPckgBuf<TCamSettingDataWhiteBalance>*>( aSettingData );
       
   277       CheckNonNullL( ptr, KErrNotFound );
       
   278 
       
   279       TCamSettingDataWhiteBalance& wbData( (*ptr)() );
       
   280       wbData.iWhiteBalanceMode = KWbModeSetting;
       
   281       break;
       
   282       }
       
   283     case ECameraSettingBrightness:
       
   284       {
       
   285       CCamera::TBrightness* ptr = 
       
   286           static_cast<CCamera::TBrightness*>( aSettingData );
       
   287       CheckNonNullL( ptr, KErrNotFound );
       
   288       *ptr = KBrightnessValue;
       
   289       break;
       
   290       }
       
   291     case ECameraSettingContrast:
       
   292       {
       
   293       CCamera::TContrast* ptr = 
       
   294           static_cast<CCamera::TContrast*>( aSettingData );
       
   295       CheckNonNullL( ptr, KErrNotFound );
       
   296       *ptr = KContrastValue;
       
   297       break;
       
   298       }
       
   299     case ECameraSettingDigitalZoom:
       
   300       {
       
   301       TInt* ptr = static_cast<TInt*>( aSettingData );
       
   302       CheckNonNullL( ptr, KErrNotFound );
       
   303       *ptr = KDigitalZoomValue;
       
   304       break;
       
   305       }
       
   306     case ECameraSettingOpticalZoom:
       
   307       {
       
   308       TInt* ptr = static_cast<TInt*>( aSettingData );
       
   309       CheckNonNullL( ptr, KErrNotFound );
       
   310       *ptr = KOpticalZoomValue;
       
   311       break;
       
   312       }
       
   313 
       
   314 #ifdef CAMERAAPP_CAPI_V2
       
   315     case ECameraSettingFocusRange:
       
   316       {
       
   317       CCamera::CCameraAdvancedSettings::TFocusRange* ptr =
       
   318           static_cast<CCamera::CCameraAdvancedSettings::TFocusRange*>( aSettingData );
       
   319       CheckNonNullL( ptr, KErrNotFound );
       
   320       *ptr = KFocusRange;
       
   321       break;
       
   322       }
       
   323 #endif // CAMERAAPP_CAPI_V2
       
   324     case ECameraSettingAudioMute:
       
   325       {
       
   326       TBool* ptr = static_cast<TBool*>( aSettingData );
       
   327       CheckNonNullL( ptr, KErrNotFound );
       
   328       *ptr = EFalse;
       
   329       break;
       
   330       }
       
   331     case ECameraSettingContAF:  
       
   332       {
       
   333       TBool* ptr = static_cast<TBool*>( aSettingData );
       
   334       CheckNonNullL( ptr, KErrNotFound );
       
   335       *ptr = ETrue;
       
   336       break;
       
   337       }
       
   338     case ECameraSettingFileMaxSize:
       
   339       {
       
   340       TInt* ptr = static_cast<TInt*>( aSettingData );
       
   341       CheckNonNullL( ptr, KErrNotFound );
       
   342       *ptr = 0; // not limited
       
   343       break;
       
   344       }
       
   345     case ECameraSettingFileName:
       
   346       {
       
   347       TPtr* ptr = static_cast<TPtr*>( aSettingData );
       
   348       CheckNonNullL( ptr, KErrNotFound );
       
   349       *ptr = iController.CurrentFullFileName();
       
   350       break;
       
   351       }
       
   352     default:
       
   353       {
       
   354       User::Leave( KErrNotSupported );
       
   355       break;
       
   356       }
       
   357     }
       
   358   }
       
   359 
       
   360 
       
   361 // ---------------------------------------------------------------------------
       
   362 //
       
   363 // ---------------------------------------------------------------------------
       
   364 //
       
   365 void 
       
   366 CCamConstantSettingProvider::ProvidePendingSettingChangesL( 
       
   367     RArray<NCamCameraController::TCamCameraSettingId>& aSettingIds )
       
   368   {
       
   369   PRINT( _L("Camera => CCamConstantSettingProvider::ProvidePendingSettingChangesL") );
       
   370   aSettingIds.Reset();
       
   371   aSettingIds.ReserveL( iPendingSettingChanges.Count() );
       
   372   for( TInt i = 0; i < iPendingSettingChanges.Count(); i++ )
       
   373     {
       
   374     aSettingIds.AppendL( iPendingSettingChanges[i] );
       
   375     }    
       
   376   PRINT1( _L("Camera <> %d settings changed"), aSettingIds.Count() );
       
   377 
       
   378 
       
   379   // Update: Reset only when asked. Enables retries.
       
   380   // iPendingSettingChanges.Reset();
       
   381   PRINT( _L("Camera <= CCamConstantSettingProvider::ProvidePendingSettingChangesL") );
       
   382   }
       
   383 
       
   384 
       
   385 // ---------------------------------------------------------------------------
       
   386 // PendingSettingChangeCount
       
   387 // ---------------------------------------------------------------------------
       
   388 //
       
   389 TInt 
       
   390 CCamConstantSettingProvider::PendingSettingChangeCount() const
       
   391   {
       
   392   return iPendingSettingChanges.Count();
       
   393   }
       
   394 
       
   395 
       
   396 // ===========================================================================
       
   397 // From MCamSettingsModelObserver
       
   398 /*
       
   399 // ---------------------------------------------------------------------------
       
   400 //
       
   401 // ---------------------------------------------------------------------------
       
   402 //
       
   403 void 
       
   404 CCamConstantSettingProvider::IntegerSettingChangedL( 
       
   405     TCamSettingItemIds aSettingItem, 
       
   406     TInt//               aSettingValue
       
   407     )
       
   408   {
       
   409   TCamCameraIntSettingId cameraId = 
       
   410       Map2CameraControllerSettingId( aSettingItem );
       
   411 
       
   412   if( ECameraSettingNone != cameraId 
       
   413    && KErrNotFound == iPendingSettingChanges.Find( cameraId ) )
       
   414     {
       
   415     iPendingSettingChanges.AppendL( cameraId )
       
   416     }
       
   417   }
       
   418 
       
   419 
       
   420 // ---------------------------------------------------------------------------
       
   421 //
       
   422 // ---------------------------------------------------------------------------
       
   423 //
       
   424 void 
       
   425 CCamConstantSettingProvider::TextSettingChangedL( 
       
   426           TCamSettingItemIds aSettingItem, 
       
   427     const TDesC&//             aSettingValue
       
   428     )
       
   429   {
       
   430   TCamCameraIntSettingId cameraId = 
       
   431       Map2CameraControllerSettingId( aSettingIds[i] );
       
   432 
       
   433   if( ECameraSettingNone != cameraId )
       
   434     {
       
   435     iPendingSettingChanges.Append( cameraId )
       
   436     }
       
   437   }
       
   438 */
       
   439 // ---------------------------------------------------------------------------
       
   440 //
       
   441 // ---------------------------------------------------------------------------
       
   442 //
       
   443 void 
       
   444 CCamConstantSettingProvider::Reset()
       
   445   {
       
   446   iPendingSettingChanges.Reset();
       
   447   }
       
   448   
       
   449 // ---------------------------------------------------------------------------
       
   450 //
       
   451 // ---------------------------------------------------------------------------
       
   452 //
       
   453 void 
       
   454 CCamConstantSettingProvider
       
   455 ::AddPendingSettingChangesL( const RArray<TCamSettingItemIds>& aUiSettingIds )
       
   456   {
       
   457   iPendingSettingChanges.ReserveL( aUiSettingIds.Count() 
       
   458                                  + iPendingSettingChanges.Count() );
       
   459 
       
   460   for( TInt i = 0; i < aUiSettingIds.Count(); i++ )
       
   461     {
       
   462     AddPendingSettingChangeL( aUiSettingIds[i] );
       
   463     }
       
   464   }
       
   465 
       
   466 // ---------------------------------------------------------------------------
       
   467 //
       
   468 // ---------------------------------------------------------------------------
       
   469 //
       
   470 void 
       
   471 CCamConstantSettingProvider
       
   472 ::AddPendingSettingChangeL( TCamSettingItemIds aUiSettingId )
       
   473   {
       
   474   TCamCameraSettingId cameraId = 
       
   475       CCamSettingConversion::Map2CameraControllerSettingId( aUiSettingId );
       
   476 
       
   477   // Add each setting only once
       
   478   if( ECameraSettingNone != cameraId 
       
   479    && KErrNotFound       == iPendingSettingChanges.Find( cameraId ) )
       
   480     {
       
   481     iPendingSettingChanges.AppendL( cameraId );
       
   482     }
       
   483   }
       
   484 
       
   485 // ---------------------------------------------------------------------------
       
   486 // SetSupportedISORatesL
       
   487 //
       
   488 // ---------------------------------------------------------------------------
       
   489 //
       
   490 void 
       
   491 CCamConstantSettingProvider::SetSupportedISORatesL( const RArray<TInt>& aSupportedIsoRates )
       
   492   {
       
   493   iSupportedISORates = aSupportedIsoRates;
       
   494   if ( iSupportedISORates.Count() != 0 ) 
       
   495     {
       
   496     iValidISORates = ETrue;
       
   497     }
       
   498   }
       
   499 
       
   500 // ===========================================================================
       
   501 // private
       
   502 
       
   503 
       
   504 // ---------------------------------------------------------------------------
       
   505 //
       
   506 // ---------------------------------------------------------------------------
       
   507 //
       
   508 void 
       
   509 CCamConstantSettingProvider::ConstructL()
       
   510   {
       
   511   }
       
   512 
       
   513 // ---------------------------------------------------------------------------
       
   514 //
       
   515 // ---------------------------------------------------------------------------
       
   516 //
       
   517 CCamConstantSettingProvider
       
   518 ::CCamConstantSettingProvider( CCamAppController& aController )
       
   519   : iController( aController ),
       
   520     iPendingSettingChanges()
       
   521   {
       
   522   }
       
   523