1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <ecam/ecamadvsettingsintf.h>

    17 #include "ecamversion.h"

    18 #include <ecam/ecamconstants.h>

    19 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    20 #include <ecamadvsettingsconst.h>

    21 #include <ecamadvsettingsdef.h>

    22 #endif

    23 #include <ecam/implementationfactoryintf.h>

    24 const TInt KBaselinedFocusRanges = 0x1F;

    25 const TInt KBaselinedWhiteBalanceModes = 0x01FF;

    26 const TUint KBaselinedPixelAspectsMask = (CCamera::CCameraAdvancedSettings::EEPixelAspect59To54 << 1) - 1;

    27 const TUint KBaselinedFlashModeMask = (CCamera::EFlashManual << 1) - 1;

    28 const TUint KBaselinedPreCaptureWarning = (CCamera::CCameraAdvancedSettings::EPCWGeneralWarning << 1) - 1;

    29 const TUint KBaselinedDriveMode = (CCamera::CCameraAdvancedSettings::EDriveModeBurst << 1) - 1;

    30 

    31 /**

    32 Factory function for creating the CCameraPresets object.

    33 

    34 @param aCamera 

    35 	   a reference to a CCamera object providing the settings.

    36 

    37 @return a pointer to a fully constructed CCameraPresets object.

    38 

    39 @leave KErrNoMemory Out of memory Or any other system-wide error code.

    40 

    41 @note  Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.

    42 */

    43 EXPORT_C CCamera::CCameraPresets* CCamera::CCameraPresets::NewL(CCamera& aCamera)

    44 	{

    45 	CCamera::CCameraPresets* self = new (ELeave)CCamera::CCameraPresets(aCamera); 

    46 	CleanupStack::PushL(self);

    47 	self->ConstructL();

    48 	CleanupStack::Pop(self);

    49 	

    50 	return self; 

    51 	}

    52 	

    53 /**	

    54 CCameraPresets Constructor.

    55 

    56 @param aOwner

    57        a reference to a CCamera object providing the settings. 

    58 */

    59 EXPORT_C CCamera::CCameraPresets::CCameraPresets(CCamera& aOwner):iOwner(aOwner), iImpl(NULL), iImpl2(NULL)

    60 	{

    61 	}

    62 

    63 /**

    64 CCameraPresets second phase constructor. 

    65 

    66 Function used to initialise internal state of the object. Uses reference to the camera to retrieve 

    67 Camera presets interface pointer.

    68 

    69 @leave KErrNoMemory Out of memory. 

    70 */ 

    71 EXPORT_C void CCamera::CCameraPresets::ConstructL() 

    72 	{

    73 	iImpl = static_cast<MCameraPresets*>(iOwner.CustomInterface(KECamMCameraPresetsUid));

    74 

    75 	if (iImpl == NULL)

    76 		{

    77 		User::Leave(KErrNotSupported);

    78 		}

    79 	

    80 	iImpl2 = static_cast<MCameraPresets2*>(iOwner.CustomInterface(KECamMCameraPresets2Uid));

    81 	}

    82 

    83 /**

    84 Destructor

    85 */	

    86 EXPORT_C CCamera::CCameraPresets::~CCameraPresets()

    87 	{

    88 	if (iImpl != NULL)

    89 		{

    90 		iImpl->Release();	

    91 		}

    92 	if (iImpl2 != NULL)

    93 		{

    94 		iImpl2->Release();	

    95 		}

    96 	}	

    97      

    98 /** 

    99 Gets the presets supported by the camera. These are identified by UIDs 

   100 and relate to a known predefined outcome.

   101 The settings associated with a particular preset and their specific values 

   102 and ranges are specific to each type of camera hardware and are therefore not defined by the API. 

   103 

   104 @param  aPresets

   105         An empty array of TUids which would be populated by the implementation with 

   106         the specific supported values. If the array is empty on return, 

   107     	the camera does not support presets.   

   108 

   109 @leave KErrNoMemory Out of memory. 

   110 

   111 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   112 	    application is not prepared to receive extra added uid values (new presets added). So, any extra uid value(unrecognised)

   113 	    passed from the implementation will be filtered at this point.

   114 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   115 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values.

   116 	    

   117 @note   Any preset uid, if added in future, has to have a uid value greater than KUidECamPresetFactoryDefaultUidValue

   118 	    otherwise unrecognized preset uids could not be checked.

   119 */

   120 EXPORT_C void CCamera::CCameraPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const

   121 	{

   122 	iImpl->GetSupportedPresetsL(aPresets);

   123 	

   124     /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   125     application is not prepared to receive extra added uid values (new presets added). So, any extra uid value(unrecognised)

   126     passed from the implementation will be filtered at this point.

   127     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   128     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

   129     FilterUnrecognisedUids(aPresets, KUidECamPresetFactoryDefaultUidValue);

   130 	}

   131 	

   132 /** 

   133 Sets a specific preset supported by the device.  

   134 All clients, implementing the MCameraObserver2 interface will receive a notification 

   135 with the UID of the specific preset, signalling a new preset has been selected.

   136 

   137 @param  aPreset 

   138         The UID of the new requested preset.

   139 */

   140 EXPORT_C void CCamera::CCameraPresets::SetPreset(TUid aPreset)

   141 	{

   142 	iImpl->SetPreset(aPreset);	

   143 	}

   144 

   145 /** 

   146 Gets the current preset set on the camera.

   147 

   148 @return  The UID of the current preset. If there is no active preset then the 

   149          returned value is KNullUid. 

   150 

   151 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not 

   152 		prepared to receive extra added uid values (new presets added). So, any extra uid(unrecognised) value received from the 

   153 		implementation will be mapped to KUidECamPresetFactoryDefault at this point.

   154 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   155 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

   156 */

   157 EXPORT_C TUid CCamera::CCameraPresets::Preset() const

   158 	{

   159 	TUid preset = iImpl->Preset();

   160 	

   161 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not 

   162 	prepared to receive extra added uid values (new presets added). So, any extra uid(unrecognised) value received from the 

   163 	implementation will be mapped to KUidECamPresetFactoryDefault at this point.

   164     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   165     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

   166 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

   167 		{

   168 		if(preset.iUid > KUidECamPresetFactoryDefaultUidValue)

   169 			{

   170 			preset = KUidECamPresetFactoryDefault;

   171 			}

   172 		}

   173 	

   174 	return preset;	

   175 	}

   176 	

   177 /**

   178 Get all settings affected by the current preset. This is to say that all settings which 

   179 are related to the preset in question will be included in the list, even though the value might 

   180 not have changed. 

   181 

   182 @param  aSettings

   183         An empty array of TUids which would be populated by the implementation with 

   184         the specific settings.

   185 

   186 @leave KErrNoMemory Out of memory. 

   187 

   188 @note   if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   189 	    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

   190 	    from the implementation will be filtered at this point.

   191 	    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   192 	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

   193 */

   194 EXPORT_C void CCamera::CCameraPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const

   195 	{

   196 	iImpl->GetAffectedSettingsL(aSettings);

   197 	

   198 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   199     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

   200     from the implementation will be filtered at this point.

   201     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   202     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

   203     FilterUnrecognisedUids(aSettings, KUidECamEventCameraSettingAutoFocusType2UidValue);

   204 	}

   205 	

   206 /**

   207 Get all settings associated with a specific preset, identified by a UID. 

   208 This function does not require a preset to have been set prior the call as in 

   209 GetAffectedSettingsL() function.

   210 The returned array will contain the UIDs of all settings which are associated and 

   211 potentially affected by that particular preset.

   212 

   213 @param  aPreset 

   214         the UID of the preset in question.

   215         

   216 @param  aSettings

   217         An empty array of TUids which would be populated by the implementation with 

   218         the UIDs of the settings associated with that preset. 

   219 

   220 @leave KErrArgument If the provided preset UID is not recognised.

   221 @leave KErrNoMemory Out of memory. 

   222 

   223 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   224 	   application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

   225 	   from the implementation will be filtered at this point.

   226 	   To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   227 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values

   228 */

   229 EXPORT_C void CCamera::CCameraPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const

   230 	{

   231 	iImpl->GetAssociatedSettingsL(aPreset, aSettings);

   232 	

   233 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   234     application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

   235     from the implementation will be filtered at this point.

   236     To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   237     to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

   238     FilterUnrecognisedUids(aSettings, KUidECamEventCameraSettingAutoFocusType2UidValue);

   239 	}

   240 

   241 void CCamera::CCameraPresets::FilterUnrecognisedUids(RArray<TUid>& aUids, const TInt aBaselineUid) const

   242 	{

   243 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

   244 		{

   245 		for(TInt index =0; index < aUids.Count(); index++)

   246 			{

   247 			/** aBaselineUid is the baseline. Any uid with greater uid value means that it has 

   248 			been added in later versions */

   249 			if(aUids[index].iUid > aBaselineUid)

   250 				{

   251 				aUids.Remove(index);

   252 				index--;

   253 				}

   254 			}

   255 		}

   256 	}

   257 	

   258 /**

   259 Retrieves those settings for which ranges have been restricted in order to let the camera work in a given preset mode.

   260 The client will be notified of range restrictions through ECAM event KUidECamEventRangeRestricted. After receiving this 

   261 notification, the client may use this method to retrieve those settings whose ranges have been restricted.

   262 

   263 @param  aRangeRestrictedSettings

   264 		An array of uids which represents those settings whose ranges have been restricted. These settings are ECam 

   265 		component wide. For each of the settings, the client can query about the restricted ranges in the usual way.

   266 		Empty array indicates that there are no range restricted settings for the given preset.

   267 

   268 @leave  May leave with any error code.

   269 

   270 @publishedPartner

   271 @prototype

   272 */

   273 EXPORT_C void CCamera::CCameraPresets::GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const

   274 	{

   275 	if(iImpl2 != NULL)

   276 		{

   277 		iImpl2->GetRangeRestrictedSettingsL(aRangeRestrictedSettings);	

   278 		}

   279 	else

   280 		{

   281 		User::Leave(KErrNotSupported);	

   282 		}	

   283 	}

   284 

   285 /**

   286 Retrieves those settings which have been restricted (settings no longer supported) in order to let the camera work in 

   287 a given preset mode. 

   288 The client will be notified of feature restrictions through ECAM event KUidECamEventFeatureRestricted. After receiving 

   289 this notification, the client may use this method to retrieve these settings.

   290 

   291 @param  aFeatureRestrictedSettings

   292 		An array of uids which represents those settings which have been restricted. These settings are ECam 

   293 		component wide. Empty array indicates that there are no settings which have been been restricted for 

   294 		the given preset.

   295 

   296 @leave  May leave with any error code.

   297 

   298 @publishedPartner

   299 @prototype

   300 */

   301 EXPORT_C void CCamera::CCameraPresets::GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const

   302 	{

   303 	if(iImpl2 != NULL)

   304 		{

   305 		iImpl2->GetFeatureRestrictedSettingsL(aFeatureRestrictedSettings);	

   306 		}

   307 	else

   308 		{

   309 		User::Leave(KErrNotSupported);	

   310 		}	

   311 	}

   312 

   313 /**

   314 Retrieves information about whether the preset unlock feature is supported or not. Unlocking the preset helps in making

   315 further setting changes after the camera works in a particular preset mode.

   316 

   317 @param  aUnlockSupported

   318 		ETrue indicates preset unlock feature is supported.

   319 		EFalse indicates preset lock feature is not supported.

   320 		

   321 @leave  May leave with any error code.

   322 

   323 @publishedPartner

   324 @prototype

   325 */

   326 EXPORT_C void CCamera::CCameraPresets::IsPresetUnlockSupportedL(TBool& aUnlockSupported) const

   327 	{

   328 	if(iImpl2 != NULL)

   329 		{

   330 		iImpl2->IsPresetUnlockSupportedL(aUnlockSupported);	

   331 		}

   332 	else

   333 		{

   334 		User::Leave(KErrNotSupported);	

   335 		}		

   336 	}

   337 

   338 /**

   339 Locks the preset for any further setting changes.

   340 

   341 @note   Event KUidECamEventPresetLocked is used to notify clients that the preset has been locked.

   342 

   343 @publishedPartner

   344 @prototype

   345 */

   346 EXPORT_C void CCamera::CCameraPresets::LockPresetL()

   347 	{

   348 	if(iImpl2 != NULL)

   349 		{

   350 		iImpl2->LockPreset();	

   351 		}

   352 	else

   353 		{

   354 		User::Leave(KErrNotSupported);	

   355 		}	

   356 	}

   357 

   358 /**

   359 Unlocks the preset to apply further setting changes.

   360 

   361 @note   Event KUidECamEventPresetUnlocked is used to notify clients that the preset has been unlocked.

   362 

   363 @publishedPartner

   364 @prototype

   365 */

   366 EXPORT_C void CCamera::CCameraPresets::UnlockPresetL()

   367 	{

   368 	if(iImpl2 != NULL)

   369 		{

   370 		iImpl2->UnlockPreset();	

   371 		}

   372 	else

   373 		{

   374 		User::Leave(KErrNotSupported);	

   375 		}

   376 	}

   377 

   378 /**

   379 Factory function for creating the CCameraAdvancedSettings object.

   380 

   381 @param aCamera 

   382 	a reference to a CCamera object providing the settings.

   383 

   384 @return a pointer to a fully constructed CCameraAdvancedSettings object.

   385 

   386 @leave KErrNoMemory Out of memory or any other system-wide error code.

   387 

   388 @note  Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.

   389 */

   390 EXPORT_C CCamera::CCameraAdvancedSettings* CCamera::CCameraAdvancedSettings::NewL(CCamera& aCamera)

   391 	{

   392 	CCamera::CCameraAdvancedSettings* self = new (ELeave)CCamera::CCameraAdvancedSettings(aCamera); 

   393 	CleanupStack::PushL(self);

   394 	self->ConstructL();

   395 	CleanupStack::Pop(self);

   396 

   397 	return self; 

   398 	}

   399 	

   400 /**	

   401 CCameraAdvancedSettings Constructor.

   402 

   403 @param aOwner

   404        a reference to a CCamera object providing the settings. 

   405 */

   406 EXPORT_C CCamera::CCameraAdvancedSettings::CCameraAdvancedSettings(CCamera& aOwner) : iOwner(aOwner), iImpl(NULL), iImpl2(NULL), iImpl3(NULL), iImpl4(NULL)

   407 	{

   408 	}

   409 

   410 /**

   411 CCameraAdvancedSettings second phase constructor.

   412  

   413 Function used to initialise internal state of the object. Uses reference to the camera to retrieve 

   414 Camera advanced settings interface pointer.

   415 

   416 @leave KErrNoMemory Out of memory.

   417 */ 

   418 EXPORT_C void CCamera::CCameraAdvancedSettings::ConstructL() 

   419 	{

   420 	iImpl = static_cast<MCameraAdvancedSettings*>(iOwner.CustomInterface(KECamMCameraAdvancedSettingsUid));

   421 	if (iImpl == NULL)

   422 		{

   423 		User::Leave(KErrNotSupported);

   424 		}

   425 	iImpl2 = static_cast<MCameraAdvancedSettings2*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings2Uid));

   426 	iImpl3 = static_cast<MCameraAdvancedSettings3*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings3Uid));

   427 	iImpl4 = static_cast<MCameraAdvancedSettings4*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings4Uid));

   428 	}

   429 	

   430 /**

   431 Destructor

   432 */	

   433 EXPORT_C CCamera::CCameraAdvancedSettings::~CCameraAdvancedSettings()

   434 	{

   435 	if (iImpl != NULL)

   436 		{

   437 		iImpl->Release();	

   438 		}

   439 	if (iImpl2 != NULL)

   440 		{

   441 		iImpl2->Release();	

   442 		}

   443 	if (iImpl3 != NULL)

   444 		{

   445 		iImpl3->Release();	

   446 		}

   447 	if (iImpl4 != NULL)

   448 		{

   449 		iImpl4->Release();	

   450 		}

   451 	}

   452 

   453 /** 

   454 Gets the type of this camera. 

   455 @see TCameraType

   456 

   457 @return the type of this camera 

   458 */	

   459 EXPORT_C CCamera::CCameraAdvancedSettings::TCameraType CCamera::CCameraAdvancedSettings::CameraType() const

   460 	{

   461 	return iImpl->CameraType();

   462 	}

   463 	

   464 /** 

   465 Get the type of a specific camera denoted by its index. A pluggable camera

   466 may not necessarily be physically present. The type denotes whether the slot allocated

   467 to that index is for pluggable or onboard camera. 

   468 @see TCameraType

   469 

   470 @param aCameraIndex

   471        An integer in the range of [0: CCamera::CamerasAvailable()-1].

   472        

   473 @return the TCameraType value for the specific camera. 

   474         If the index is out of range, the return value is ECameraUnknown.

   475 */

   476 EXPORT_C CCamera::CCameraAdvancedSettings::TCameraType CCamera::CCameraAdvancedSettings::CameraType(TInt aCameraIndex) 

   477 	{

   478 	return iImpl->CameraType(aCameraIndex);

   479 	}

   480 	

   481 /** 

   482 Checks whether the current camera is present.

   483        

   484 @return Whether the camera is currently present. 

   485 		ETrue if camera is present, EFalse otherwise. 

   486 		For example ECameraOnBoard (built-in) cameras are always present.   

   487 */	

   488 EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsCameraPresent() const

   489 	{

   490 	return iImpl->IsCameraPresent();

   491 	}

   492 	

   493 /** 

   494 Checks whether the camera, denoted by its index, is currently present.

   495 The index uniquely identifies the camera on the device.

   496 

   497 @param aCameraIndex

   498        An integer in the range of [0:CCamera::CamerasAvailable()-1] specifying the

   499        camera device to use

   500        

   501 @return Whether the camera is currently present. 

   502 		ETrue if camera is present, EFalse otherwise. 

   503 		For example  built-in (ECameraOnBoard) cameras 

   504 		are always present. 

   505 */	

   506 EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsCameraPresent(TInt aCameraIndex) 

   507 	{

   508 	return iImpl->IsCameraPresent(aCameraIndex);

   509 	}

   510 	

   511 /**

   512 Gets current camera index. The index uniquely identifies the camera on the device.

   513  

   514 @return camera index in the inclusive range of [0:CCamera::CamerasAvailable() - 1].

   515 */

   516 EXPORT_C TInt CCamera::CCameraAdvancedSettings::CameraIndex() const

   517 	{

   518 	return iImpl->CameraIndex(); 

   519 	}

   520 	

   521 /** 

   522 Gets all of the supported stabilization modes on the camera. The result is a bitfield

   523 of the valid TStabilizationMode flags. 

   524 @see TStabilizationMode

   525 

   526 @return a bitfield of all supported stabilization modes. 

   527 */

   528 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationModes() const

   529 	{

   530 	return iImpl->SupportedStabilizationModes();

   531 	}

   532 	

   533 /** 

   534 Gets current stabilization mode on the camera. 

   535 The result is a valid TStabilizationMode value. 

   536 

   537 @return current stabilization mode of type TStabilizationMode. 

   538 */

   539 EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationMode CCamera::CCameraAdvancedSettings::StabilizationMode() const

   540 	{

   541 	return iImpl->StabilizationMode();

   542 	}

   543 	

   544 /** 

   545 Sets a specific stabilization mode on the camera.

   546 

   547 Stabilization mode change fires a KUidECamEventCameraSettingStabilizationMode

   548 event to all MCameraObserver2 clients of this specific camera.

   549 

   550 @param aStabilizationMode

   551        new stabilization mode of TStabilizationMode type.

   552 */	

   553 EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)

   554 	{

   555 	iImpl->SetStabilizationMode(aStabilizationMode);

   556 	}

   557 	

   558 /** 

   559 Gets all of the supported focus modes on the camera. The result is a bitfield

   560 of the valid TFocusMode flags. 

   561 @see TFocusMode 

   562 

   563 @return a bitfield of all supported focus modes. 

   564 */

   565 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFocusModes() const

   566 	{

   567 	return iImpl->SupportedFocusModes();

   568 	}

   569 	

   570 /** 

   571 Gets current focus mode on the camera. 

   572 The result is a valid TFocusMode value. 

   573 

   574 @return current focus mode. 

   575 */

   576 EXPORT_C CCamera::CCameraAdvancedSettings::TFocusMode CCamera::CCameraAdvancedSettings::FocusMode() const

   577 	{

   578 	return iImpl->FocusMode();

   579 	}

   580 	

   581 /** 

   582 Sets a specific focus mode on the camera.

   583 Focus mode change fires a KUidECamEventCameraSettingFocusMode event

   584 to all MCameraObserver2 clients of the camera.

   585 

   586 @param aFocusMode 

   587        new focus mode of TFocusMode type.

   588 */

   589 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)

   590 	{

   591 	iImpl->SetFocusMode(aFocusMode);

   592 	}

   593 	

   594 /** 

   595 Gets all supported focus ranges on the camera.

   596 

   597 @return an integer - a bitfield of all supported TFocusRange values.

   598 

   599 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   600 	   application is not prepared to receive extra added enum values. So, any extra enum value passed 

   601 	   from the implementation will be filtered at this point.

   602 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   603 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values 

   604 */

   605 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFocusRanges() const

   606 	{

   607 	TInt supportedFocusRanges = iImpl->SupportedFocusRanges();

   608 	

   609 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   610 	   application is not prepared to receive extra added enum values. So, any extra enum value passed 

   611 	   from the implementation will be filtered at this point.

   612 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   613 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

   614 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

   615 		{

   616 		supportedFocusRanges &= KBaselinedFocusRanges;

   617 		}

   618 	

   619 	return supportedFocusRanges;

   620 	}

   621     

   622 /** 

   623 Gets current focus range on the camera.

   624 

   625 @return the current TFocusRange value. 

   626 

   627 @note  if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   628 	   application is not prepared to receive extra added enum values. So, any extra enum value received 

   629 	   from the implementation will be dropped and EFocusRangeAuto would be passed instead.

   630 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   631 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values

   632 */	

   633 EXPORT_C CCamera::CCameraAdvancedSettings::TFocusRange CCamera::CCameraAdvancedSettings::FocusRange() const

   634 	{

   635 	CCamera::CCameraAdvancedSettings::TFocusRange focusRange = iImpl->FocusRange();

   636 	

   637 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   638 	   application is not prepared to receive extra added enum values. So, any extra enum value received 

   639 	   from the implementation will be dropped and EFocusRangeAuto would be passed instead.

   640 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   641 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

   642 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

   643 		{

   644 		if(static_cast<TInt>(focusRange) > KBaselinedFocusRanges)

   645 			{

   646 			focusRange = CCamera::CCameraAdvancedSettings::EFocusRangeAuto;

   647 			}

   648 		}

   649 	

   650 	return focusRange;

   651 	}

   652 	

   653 /** 

   654 Sets a specific focus range on the camera.

   655 The focus range change fires both, KUidECamEventCameraSettingFocusRange and 

   656 KUidECamEventCameraSettingFocusRange2 event to all MCameraObserver2 clients of the camera.

   657 @see KUidECamEventCameraSettingFocusRange

   658 

   659 @param aFocusRange

   660        newly selected focus range.

   661 */

   662 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)

   663 	{

   664 	iImpl->SetFocusRange(aFocusRange);

   665 	}

   666 	

   667 /** 

   668 Gets all supported auto focus types on the camera.

   669 

   670 @return an integer - a bitfield of all supported TAutoFocusType values. 

   671 */

   672 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedAutoFocusTypes() const

   673 	{

   674 	return iImpl->SupportedAutoFocusTypes();

   675 	}

   676 

   677 /** 

   678 Gets current auto focus type on the camera. 

   679 @see TAutoFocusType

   680 

   681 @return a CCamera::TAutoFocusType value. 

   682 */	

   683 EXPORT_C CCamera::CCameraAdvancedSettings::TAutoFocusType CCamera::CCameraAdvancedSettings::AutoFocusType() const

   684 	{

   685 	return iImpl->AutoFocusType();

   686 	}

   687 	

   688 /** 

   689 Sets a specific auto focus type on the camera.

   690 The focus type change fires both, KUidECamEventCameraSettingAutoFocusType and 

   691 KUidECamEventCameraSettingAutoFocusType2 event to all MCameraObserver2 clients of the camera.

   692 @see KUidECamEventCameraSettingAutoFocusType

   693 

   694 @param aAutoFocusType

   695        Autofocus selection.

   696 */

   697 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)

   698 	{

   699 	iImpl->SetAutoFocusType(aAutoFocusType);

   700 	}

   701 	

   702 /** 

   703 Gets all supported auto focus areas on the camera.

   704 

   705 @return an integer - a bitfield of al supported TAutoFocusArea values. 

   706 */	

   707 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedAutoFocusAreas() const

   708 	{

   709 	return iImpl->SupportedAutoFocusAreas();

   710 	}

   711 	

   712 /** 

   713 Gets current chosen auto focus area on the camera.

   714 

   715 @return a CCamera::TAutoFocusArea value. 

   716 */

   717 EXPORT_C CCamera::CCameraAdvancedSettings::TAutoFocusArea CCamera::CCameraAdvancedSettings::AutoFocusArea() const

   718 	{

   719 	return iImpl->AutoFocusArea();

   720 	}

   721 	

   722 /** 

   723 Sets a specific auto focus area on the camera.

   724 Focus area change fires a KUidECamEventCameraSettingAutoFocusArea event

   725 to all MCameraObserver2 clients of the camera.

   726 

   727 @param aAutoFocusArea

   728        Autofocus area selection.

   729 */

   730 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)

   731 	{

   732 	iImpl->SetAutoFocusArea(aAutoFocusArea);

   733 	}

   734 	

   735 /**

   736 Get focus distance in millimetres.

   737 

   738 @return the current focus distance in millimetres, directly from user setting of lenses.

   739 */

   740 EXPORT_C TInt CCamera::CCameraAdvancedSettings::FocusDistance() const

   741 	{

   742 	return iImpl->FocusDistance();

   743 	}

   744 

   745 /**

   746 Set focus distance in millimetres. Focus distance change fires a KUidECamEventCameraSettingFocusDistance event

   747 to all MCameraObserver2 clients of the camera.

   748 

   749 @param aDistance 

   750 	   the new distance value in millimetres.

   751 

   752 @note  KUidECamEvent2CameraSettingFocusDistance may be used to provide the focussing feedback as well. This means that 

   753 	   the feedback will state whether the proper focussing has been achieved after setting the given focus distance.

   754 */

   755 EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusDistance(TInt aDistance)

   756 	{

   757 	iImpl->SetFocusDistance(aDistance);

   758 	}

   759 	

   760 /**

   761 Get minimum focus distance in millimetres 

   762 

   763 @return the minimum (35 camera equivalent) focal length of a camera. 

   764 @note Current Focal length is calculated as focalLength = opticalZoom * minFocalLength;  

   765 */

   766 EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetMinFocalLength() const

   767 	{

   768 	return iImpl->GetMinFocalLength();

   769 	}

   770 	

   771 /**

   772 Gets the set of camera supported ISO rates.

   773 

   774 @param aSupportedIsoRates

   775        an array of integers which gets filled with the supported ISO rates. 

   776        

   777 @note  When camera device is incapable of revealing the ISO rates supported, it has to be assumed that 

   778 	   camera will work only on the permanently set value. If this value is not known, empty array may be 

   779 	   returned; corresponding getter/setters for this feature should not be used in such a case.

   780 */

   781 EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const

   782 	{

   783 	iImpl->GetSupportedIsoRatesL(aSupportedIsoRates);

   784 	}

   785 	

   786 /**

   787 Gets current ISO rate.

   788 

   789 @return current ISO rate as a TInt value. 

   790 		Negative value returned means error case (system wide error code) and positive value means current ISO rate.

   791 

   792 @note The returned value may be checked with the list of supported ISO rates. If value returned does not belong to 

   793 	  this list, then it may be treated as an error case.

   794 */

   795 EXPORT_C TInt CCamera::CCameraAdvancedSettings::IsoRate() const

   796 	{

   797 	return iImpl->IsoRate();

   798 	}

   799 

   800 /**

   801 Set current ISO rate for the camera.

   802 Triggers KUidECamEventCameraSettingIsoRate to all MCameraObserver2 clients of the camera.

   803 

   804 @param aRate

   805 	   required new ISO rate.

   806 */

   807 EXPORT_C void CCamera::CCameraAdvancedSettings::SetIsoRate(TInt aRate)

   808 	{

   809 	iImpl->SetIsoRate(aRate);

   810 	}

   811 	

   812 /** 

   813 Gets the current discrete aperture steps (F-stops) supported by the camera.

   814 

   815 @param  aFStops

   816         A reference to an empty array of TInt which would be populated by the implementation with 

   817         the specific supported values. If the array is empty on return, 

   818         the camera supports all integer values in the aperture range. Each value is multiplied by 

   819         a factor of KECamFineResolutionFactor.

   820 

   821 @param  aInfo 

   822         a reference to TValueInfo, which establishes the type of the returned data.     

   823 

   824 @leave KErrNoMemory Out of memory. 

   825 

   826 @note  When camera device is incapable of revealing the aperture openings supported, it has to be assumed that 

   827 	   camera will work only on the parmanently set value. If this value is not known, empty array may be 

   828 	   returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

   829 */

   830 EXPORT_C void CCamera::CCameraAdvancedSettings::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const

   831 	{

   832 	iImpl->GetAperturesL(aFStops, aInfo);

   833 	}

   834 

   835 /** 

   836 Get current aperture value.

   837 The default aperture value is ECAM implementation specific and could be either auto aperture or any other supported value.

   838  

   839 @return Current aperture value as an integer, multiplied by KECamFineResolutionFactor. 

   840 	    For example the function will return 280 for the actual aperture of F2.8. 

   841 	    Negative value returned means error case (system wide error code) and positive value means current aperture.

   842 */

   843 EXPORT_C TInt CCamera::CCameraAdvancedSettings::Aperture() const

   844 	{

   845 	return iImpl->Aperture();

   846 	}

   847 

   848 /** 

   849 Set a new aperture value. 

   850 All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingAperture 

   851 event notification when aperture value is changed.

   852 

   853 @param aFStop 

   854 	   a new aperture value in the supported by the camera range.       

   855 

   856 @note The aperture parameter value is an integer, multiplied by KECamFineResolutionFactor. 

   857 	  For example to set an aperture of F2.8, call SetAperture(280).

   858 

   859 */

   860 EXPORT_C void CCamera::CCameraAdvancedSettings::SetAperture(TInt aFStop) 

   861 	{

   862 	iImpl->SetAperture(aFStop); 

   863 	}

   864 

   865 /**

   866 Gets the set of supported shutter speeds.

   867 

   868 @param  aShutterSpeeds

   869 		a reference to an RArray of TInt representing the discrete shutter speeds supported 

   870 		currently by the camera.

   871 

   872 @param  aInfo 

   873 		a reference to TValueInfo, which establishes the type of the returned data.     

   874 

   875 @return the populated array with all shutter speeds in microseconds. 

   876 

   877 @leave KErrNoMemory Out of memory. 

   878 

   879 @note  When camera device is incapable of revealing the shutter speeds supported, it has to be assumed that 

   880 	   camera will work only on the parmanently set value. If this value is not known, empty array may be 

   881 	   returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.

   882 */

   883 EXPORT_C void CCamera::CCameraAdvancedSettings::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const 

   884 	{

   885 	iImpl->GetShutterSpeedsL(aShutterSpeeds, aInfo);

   886 	}

   887 

   888 /**

   889 Gets the current shutter speed

   890 

   891 @return the current shutter speed in microseconds. 

   892 		Negative value returned means error case (system wide error code) and positive value means current shutter speed.

   893 */

   894 EXPORT_C TInt CCamera::CCameraAdvancedSettings::ShutterSpeed() const 

   895 	{

   896 	return iImpl->ShutterSpeed();

   897 	}

   898 

   899 /**

   900 Sets the current shutter speed. When set, all MCameraObserver2 clients of the camera

   901 receive a KUidECamEventCameraSettingShutterSpeed event

   902 

   903 @param aShutterSpeed

   904        the required shutter speed in microseconds.

   905 */

   906 EXPORT_C void CCamera::CCameraAdvancedSettings::SetShutterSpeed(TInt aShutterSpeed) 

   907 	{

   908 	iImpl->SetShutterSpeed(aShutterSpeed); 

   909 	}

   910 

   911 /**

   912 Get all supported metering modes on this camera represented as bitfield of type TMeteringMode.

   913 

   914 @return the set of supported metering modes.

   915 */

   916 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedMeteringModes() const

   917 	{

   918 	return iImpl->SupportedMeteringModes();

   919 	}

   920 

   921 /**

   922 Get current metering mode.

   923 

   924 @return a value of type TMeteringMode.

   925 */

   926 EXPORT_C CCamera::CCameraAdvancedSettings::TMeteringMode CCamera::CCameraAdvancedSettings::MeteringMode() const

   927 	{

   928 	return iImpl->MeteringMode();

   929 	}

   930 

   931 /**

   932 Set the current metering mode. When set, all MCameraObserver2 clients are notified 

   933 with a KUidECamEventCameraSettingMeteringMode event. 

   934 

   935 @param aMeteringMode

   936 		new selection for metering mode of type TMeteringMode.

   937 */

   938 EXPORT_C void CCamera::CCameraAdvancedSettings::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)

   939 	{

   940 	iImpl->SetMeteringMode(aMeteringMode);

   941 	}

   942 

   943 /** 

   944 Get all supported drive modes as bitfields of TDriveMode type. 

   945 

   946 @return the set of supported drive modes.

   947 */

   948 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedDriveModes() const

   949 	{

   950 	TInt supportedDriveModes = iImpl->SupportedDriveModes();

   951 

   952 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   953   	application is not prepared to receive extra added enum values. So, any extra enum value passed 

   954    	from the implementation will be filtered at this point.

   955    	To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   956    	to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

   957 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

   958 		{

   959 		supportedDriveModes &= KBaselinedDriveMode;

   960 		}

   961 

   962 	return supportedDriveModes;

   963 	}

   964 

   965 /** 

   966 Gets currently active drive mode.

   967 

   968 @return current drive mode.

   969 */

   970 EXPORT_C CCamera::CCameraAdvancedSettings::TDriveMode CCamera::CCameraAdvancedSettings::DriveMode() const

   971 	{

   972 	CCamera::CCameraAdvancedSettings::TDriveMode driveMode = iImpl->DriveMode();

   973 

   974 	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

   975 	   application is not prepared to receive extra added enum values. So, any extra enum value received 

   976 	   from the implementation will be dropped and EDriveModeAuto would be passed instead.

   977 	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

   978 	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

   979 	if(iOwner.CameraVersion() == KCameraDefaultVersion)

   980 		{

   981 		if(static_cast<TUint>(driveMode) > KBaselinedDriveMode)

   982 			{

   983 			driveMode = CCamera::CCameraAdvancedSettings::EDriveModeAuto;

   984 			}

   985 		}

   986 	

   987 	return driveMode;

   988 	}

   989 

   990 /**

   991 Set the current metering mode. When set all MCameraObserver2 clients  are notified with 

   992 KUidECamEventCameraSettingDriveMode. 

   993 

   994 @param aDriveMode

   995 	   new selection for drive mode value of type TDriveMode.

   996 

   997 @note  Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or StartPerformantVideoCaptureL())

   998 	   if an image/video capture is still outstanding, this method may report error KErrInUse.

   999 */

  1000 EXPORT_C void CCamera::CCameraAdvancedSettings::SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)

  1001 	{

  1002 	iImpl->SetDriveMode(aDriveMode);

  1003 	}

  1004 

  1005 /**

  1006 Get all supported bracket modes as bitfields.

  1007 

  1008 @return the set of all supported bracket modes as an integer.

  1009 */

  1010 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketModes() const

  1011 	{

  1012 	return iImpl->SupportedBracketModes();

  1013 	}

  1014 

  1015 /**

  1016 Get current bracket mode.

  1017 

  1018 @return the current bracket mode TBracketMode.

  1019 */

  1020 EXPORT_C CCamera::CCameraAdvancedSettings::TBracketMode CCamera::CCameraAdvancedSettings::BracketMode() const

  1021 	{

  1022 	return iImpl->BracketMode();

  1023 	}

  1024 

  1025 /**

  1026 Set new bracket mode. All MCameraObserver2 clients are notified with 

  1027 KUidECamEventCameraSettingBracketMode. 

  1028 

  1029 @param aBracketMode

  1030 	   new selection for bracket mode of type TBracketMode.

  1031 */

  1032 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)

  1033 	{

  1034 	iImpl->SetBracketMode(aBracketMode);

  1035 	}

  1036 

  1037 /**

  1038 Get all supported bracket parameters as bitfields.

  1039 

  1040 @return the set of all currently supported bracket modes.

  1041 */

  1042 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketParameters() const

  1043 	{

  1044 	return iImpl->SupportedBracketParameters();

  1045 	}

  1046 

  1047 /**

  1048 Get current bracket parameter.

  1049 

  1050 @return the current bracket mode TBracketParameter.

  1051 */

  1052 EXPORT_C CCamera::CCameraAdvancedSettings::TBracketParameter CCamera::CCameraAdvancedSettings::BracketParameter() const

  1053 	{

  1054 	return iImpl->BracketParameter();

  1055 	}

  1056 

  1057 /**

  1058 Set new bracket parameter

  1059 When set all clients are notified with 

  1060 KUidECamEventCameraSettingBracketParameter. 

  1061 

  1062 @param aBracketParameter

  1063 	   new selection for parameter type of type TBracketParameter.

  1064 */

  1065 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)

  1066 	{

  1067 	iImpl->SetBracketParameter(aBracketParameter);

  1068 	}

  1069 

  1070 /**

  1071 Get all supported bracket steps as bitfields.

  1072 

  1073 @return the set of all supported bracket modes.

  1074 */

  1075 EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketSteps() const

  1076 	{

  1077 	return iImpl->SupportedBracketSteps();

  1078 	}

  1079 

  1080 /**

  1081 Get current bracket step.

  1082 

  1083 @return the current bracket mode TBracketStep.

  1084 */

  1085 EXPORT_C CCamera::CCameraAdvancedSettings::TBracketStep CCamera::CCameraAdvancedSettings::BracketStep() const

  1086 	{

  1087 	return iImpl->BracketStep();

  1088 	}

  1089 

  1090 /**

  1091 Set new bracket step. All MCameraObserver2 clients are notified with 

  1092 KUidECamEventCameraSettingBracketStep. 

  1093 

  1094 @param aBracketStep

  1095 	   new selection for step of type TBracketStep.

  1096 */

  1097 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)	

  1098 	{

  1099 	iImpl->SetBracketStep(aBracketStep);

  1100 	}

  1101 

  1102 /** 

  1103 Gets the settings for which frames to merge. Valid only in EDriveModeBracketMerge mode. 

  1104 @note there must be at least two images to merge. All are assumed to form a sequence and 

  1105 	are identified using the first frame index and number of frames e.g. to  merge two frames - one 

  1106 	on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to two.

  1107 @note It is very much TBracketMode setting dependent operation. 

  1108 

  1109 @param  aStartIndex

  1110 		the index of the start frame, starts from 0.

  1111 		

  1112 @param  aFrames

  1113 		the number of frames to be merged.		

  1114 */

  1115 EXPORT_C void CCamera::CCameraAdvancedSettings::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const	

  1116 	{

  1117 	iImpl->GetBracketMerge(aStartIndex, aFrames);

  1118 	}

  1119 

  1120 /** 

  1121 Sets the settings for which frames to merge. Valid only in EDriveModeBracketMerge mode. 

  1122 @note there must be at least two images to merge. All are assumed to form a sequence and 

  1123 	are identified using the first frame index and number of frames e.g. to  merge two frames - one 

  1124 	on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to 2.

  1125 	MCameraObserver2 clients are notified with a KUidECamEventBracketMerge event.

  1126 

  1127 @note It is very TBracketMode setting dependent. 

  1128 	

  1129 @param  aStartIndex

  1130 		the index of the start frame, starts from 0.

  1131 		

  1132 @param  aFrames

  1133 		the number of frames to be merged.		

  1134 */

  1135 EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketMerge(TInt aStartIndex, TInt aFrames)