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".
8 // Initial Contributors:
9 // Nokia Corporation - initial contribution.
21 #ifndef ECAMADVSETTINGS_H
22 #define ECAMADVSETTINGS_H
26 #include <ecamadvsettingsuids.hrh>
29 #include <ecam/ecamconstants.h>
30 #include <ecamimageprocessing.h>
31 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
32 #include <ecamadvsettingsconst.h>
33 #include <ecamadvsettingsdef.h>
37 class MCameraAdvancedSettings;
38 class MCameraAdvancedSettings2;
39 class MCameraAdvancedSettings3;
40 class MCameraAdvancedSettings4;
41 class MCameraPresets2;
42 class MCameraContinuousZoom;
44 /* General purpose constants */
48 UID used to identify the CCamera Advanced Settings API.
49 This API is used to control specific individual advanced settings of camera hardware.
50 These settings directly relate to the image acquisition phase.
52 @see CCamera::CCameraAdvancedSettings
54 static const TUid KECamAdvancedSettingUid = {KECamAdvancedSettingUidValue};
57 UID used to identify the CCamera Presets API.
58 This API is used to simplify user - camera interaction by allowing simultaneous
59 setting of various advanced camera hardware settings using a single predefined parameter.
60 @see CCamera::CCameraPresets
62 static const TUid KECamPresetsUid = {KECamPresetsUidValue};
64 /** All clients receive these events, irrespective of camera index. */
65 /** Camera slots in for 8 cameras. */
66 /** Camera with index 0 Plugged-in */
67 static const TUid KUidECamEventGlobalCamera00PluggedIn = {KUidECamEventGlobalCamera00PluggedInUidValue};
68 /** Camera with index 1 Plugged-in */
69 static const TUid KUidECamEventGlobalCamera01PluggedIn = {KUidECamEventGlobalCamera01PluggedInUidValue};
70 /** Camera with index 2 Plugged-in */
71 static const TUid KUidECamEventGlobalCamera02PluggedIn = {KUidECamEventGlobalCamera02PluggedInUidValue};
72 /** Camera with index 3 Plugged-in */
73 static const TUid KUidECamEventGlobalCamera03PluggedIn = {KUidECamEventGlobalCamera03PluggedInUidValue};
74 /** Camera with index 4 Plugged-in */
75 static const TUid KUidECamEventGlobalCamera04PluggedIn = {KUidECamEventGlobalCamera04PluggedInUidValue};
76 /** Camera with index 5 Plugged-in */
77 static const TUid KUidECamEventGlobalCamera05PluggedIn = {KUidECamEventGlobalCamera05PluggedInUidValue};
78 /** Camera with index 6 Plugged-in */
79 static const TUid KUidECamEventGlobalCamera06PluggedIn = {KUidECamEventGlobalCamera06PluggedInUidValue};
80 /** Camera with index 7 Plugged-in */
81 static const TUid KUidECamEventGlobalCamera07PluggedIn = {KUidECamEventGlobalCamera07PluggedInUidValue};
83 /** Camera slots plugged out for 8 cameras. */
84 /** Camera with index 0 Plugged-out */
85 static const TUid KUidECamEventGlobalCamera00PluggedOut = {KUidECamEventGlobalCamera00PluggedOutUidValue};
86 /** Camera with index 1 Plugged-out */
87 static const TUid KUidECamEventGlobalCamera01PluggedOut = {KUidECamEventGlobalCamera01PluggedOutUidValue};
88 /** Camera with index 2 Plugged-out */
89 static const TUid KUidECamEventGlobalCamera02PluggedOut = {KUidECamEventGlobalCamera02PluggedOutUidValue};
90 /** Camera with index 3 Plugged-out */
91 static const TUid KUidECamEventGlobalCamera03PluggedOut = {KUidECamEventGlobalCamera03PluggedOutUidValue};
92 /** Camera with index 4 Plugged-out */
93 static const TUid KUidECamEventGlobalCamera04PluggedOut = {KUidECamEventGlobalCamera04PluggedOutUidValue};
94 /** Camera with index 5 Plugged-out */
95 static const TUid KUidECamEventGlobalCamera05PluggedOut = {KUidECamEventGlobalCamera05PluggedOutUidValue};
96 /** Camera with index 6 Plugged-out */
97 static const TUid KUidECamEventGlobalCamera06PluggedOut = {KUidECamEventGlobalCamera06PluggedOutUidValue};
98 /** Camera with index 7 Plugged-out */
99 static const TUid KUidECamEventGlobalCamera07PluggedOut = {KUidECamEventGlobalCamera07PluggedOutUidValue};
101 /** Camera slots available for 8 cameras. */
102 /** Signals a camera previously has been reserved and then released again.
103 In this way available clients may attempt to reserve the camera */
104 /** Camera with index 0 Available. */
105 static const TUid KUidECamEventGlobalCamera00Available = {KUidECamEventGlobalCamera00AvailableUidValue};
106 /** Camera with index 1 Available. */
107 static const TUid KUidECamEventGlobalCamera01Available = {KUidECamEventGlobalCamera01AvailableUidValue};
108 /** Camera with index 2 Available. */
109 static const TUid KUidECamEventGlobalCamera02Available = {KUidECamEventGlobalCamera02AvailableUidValue};
110 /** Camera with index 3 Available. */
111 static const TUid KUidECamEventGlobalCamera03Available = {KUidECamEventGlobalCamera03AvailableUidValue};
112 /** Camera with index 4 Available. */
113 static const TUid KUidECamEventGlobalCamera04Available = {KUidECamEventGlobalCamera04AvailableUidValue};
114 /** Camera with index 5 Available. */
115 static const TUid KUidECamEventGlobalCamera05Available = {KUidECamEventGlobalCamera05AvailableUidValue};
116 /** Camera with index 6 Available. */
117 static const TUid KUidECamEventGlobalCamera06Available = {KUidECamEventGlobalCamera06AvailableUidValue};
118 /** Camera with index 7 Available. */
119 static const TUid KUidECamEventGlobalCamera07Available = {KUidECamEventGlobalCamera07AvailableUidValue};
121 /** Individual camera events. These are used by the camera to signal its observers. */
123 static const TUid KUidECamEventLensChanged = {KUidECamEventLensChangedUidValue};
124 /** Flash source added. */
125 static const TUid KUidECamEventFlashSourceAdded = {KUidECamEventFlashSourceAddedUidValue};
126 /** Flash source removed. */
127 static const TUid KUidECamEventFlashSourceRemoved = {KUidECamEventFlashSourceRemovedUidValue};
128 /** Image resolution changed. */
129 static const TUid KUidECamEventCameraSettingImageSize = {KUidECamEventCameraSettingImageSizeUidValue};
130 /** Image Format changed. */
131 static const TUid KUidECamEventCameraSettingImageFormat = {KUidECamEventCameraSettingImageFormatUidValue};
132 /** Camera orientation changed. */
133 static const TUid KUidECamEventCameraSettingCameraOrientation = {KUidECamEventCameraSettingCameraOrientationUidValue};
135 static const TUid KUidECamEventCameraSettingsOptimalFocus = {KUidECamEventCameraSettingsOptimalFocusUidValue};
137 /** Advanced settings. */
138 /** Stabilization mode. */
139 static const TUid KUidECamEventCameraSettingStabilizationMode = {KUidECamEventCameraSettingStabilizationModeUidValue};
141 static const TUid KUidECamEventCameraSettingFocusMode = {KUidECamEventCameraSettingFocusModeUidValue};
145 Replaced by KUidECamEventCameraSettingFocusRange2
147 In the first release of this event, KUidECamEventCameraSettingFocusRange was incorrectly given an already existing uid.
148 In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingFocusRange2.
149 Camera servers predating this API change will continue to send the original event which is indistinguishable by value.
150 Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed.
151 Camera servers which have been updated should send both KUidECamEventCameraSettingFocusRange and KUidECamEventCameraSettingFocusRange2 on a focus range change.
152 Camera clients should therefore process both events(old and new).
154 @see KUidECamEventCameraSettingFocusRange2
156 static const TUid KUidECamEventCameraSettingFocusRange = {KUidECamEventCameraSettingFocusRangeUidValue};
160 Replaced by KUidECamEventCameraSettingAutoFocusType2
162 In the first release of this event, KUidECamEventCameraSettingAutoFocusType was incorrectly given an already existing uid.
163 In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingAutoFocusType2.
164 Camera servers predating this API change will continue to send the original event which is indistinguishable by value.
165 Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed.
166 Camera servers which have been updated should send both KUidECamEventCameraSettingAutoFocusType and KUidECamEventCameraSettingAutoFocusType2 on a focus range change.
167 Camera clients should therefore process both events(old and new).
169 @see KUidECamEventCameraSettingAutoFocusType2*/
170 static const TUid KUidECamEventCameraSettingAutoFocusType = {KUidECamEventCameraSettingAutoFocusTypeUidValue};
171 /** Autofocus area. */
172 static const TUid KUidECamEventCameraSettingAutoFocusArea = {KUidECamEventCameraSettingAutoFocusAreaUidValue};
173 /** Autofocus lock state. */
174 static const TUid KUidECamEventCameraSettingAutoFocusLock = {KUidECamEventCameraSettingAutoFocusLockUidValue};
175 /** Focus distance */
176 static const TUid KUidECamEventCameraSettingFocusDistance = {KUidECamEventCameraSettingFocusDistanceUidValue};
177 /** Sensitivity - ISO rate. */
178 static const TUid KUidECamEventCameraSettingIsoRate = {KUidECamEventCameraSettingIsoRateUidValue};
180 static const TUid KUidECamEventCameraSettingAperture = {KUidECamEventCameraSettingApertureUidValue};
181 /** Aperture range. */
182 static const TUid KUidECamEventCameraSettingApertureRange = {KUidECamEventCameraSettingApertureRangeUidValue};
183 /** Shutter speed. */
184 static const TUid KUidECamEventCameraSettingShutterSpeed = {KUidECamEventCameraSettingShutterSpeedUidValue};
185 /** Shutter speed range. */
186 static const TUid KUidECamEventCameraSettingShutterSpeedRange = {KUidECamEventCameraSettingShutterSpeedRangeUidValue};
187 /** Metering mode. */
188 static const TUid KUidECamEventCameraSettingMeteringMode = {KUidECamEventCameraSettingMeteringModeUidValue};
190 static const TUid KUidECamEventCameraSettingDriveMode = {KUidECamEventCameraSettingDriveModeUidValue};
192 static const TUid KUidECamEventCameraSettingBracketMode = {KUidECamEventCameraSettingBracketModeUidValue};
194 static const TUid KUidECamEventCameraSettingBracketStep = {KUidECamEventCameraSettingBracketStepUidValue};
195 /** Bracket parameter. */
196 static const TUid KUidECamEventCameraSettingBracketParameter = {KUidECamEventCameraSettingBracketParameterUidValue};
197 /** Bracket merge. */
198 static const TUid KUidECamEventBracketMerge = {KUidECamEventBracketMergeUidValue};
199 /** Picture orientation. */
200 static const TUid KUidECamEventCameraSettingPictureOrientation = {KUidECamEventCameraSettingPictureOrientationUidValue};
201 /** Automatic size selection option */
202 static const TUid KUidECamEventCameraSettingAutomaticSizeSelection = {KUidECamEventCameraSettingAutomaticSizeSelectionUidValue};
203 /** Flash setting. */
204 static const TUid KUidECamEventCameraSettingFlashMode = {KUidECamEventCameraSettingFlashModeUidValue};
205 /** Flash compensation step. */
206 static const TUid KUidECamEventCameraSettingFlashCompensationStep = {KUidECamEventCameraSettingFlashCompensationStepUidValue};
207 /** Flash compensation. */
208 static const TUid KUidECamEventCameraSettingFlashCompensation = {KUidECamEventCameraSettingFlashCompensationUidValue};
209 /** Manual flash power. */
210 static const TUid KUidECamEventCameraSettingFlashManualPower = {KUidECamEventCameraSettingFlashManualPowerUidValue};
211 /** Red eye reduce mode. */
212 static const TUid KUidECamEventCameraSettingFlashRedEyeReduce = {KUidECamEventCameraSettingFlashRedEyeReduceUidValue};
213 /** Exposure mode setting. */
214 static const TUid KUidECamEventCameraSettingExposureMode = {KUidECamEventCameraSettingExposureModeUidValue};
215 /** Exposure compensation step. */
216 static const TUid KUidECamEventCameraSettingExposureCompensationStep = {KUidECamEventCameraSettingExposureCompensationStepUidValue};
217 /** Exposure compensation. */
218 static const TUid KUidECamEventCameraSettingExposureCompensation = {KUidECamEventCameraSettingExposureCompensationUidValue};
219 /** Exposure lock state. */
220 static const TUid KUidECamEventCameraSettingExposureLock = {KUidECamEventCameraSettingExposureLockUidValue};
221 /** AE lock option. */
222 static const TUid KUidECamEventAELock = {KUidECamEventAELockUidValue};
223 /** White balance. */
224 static const TUid KUidECamEventCameraSettingWhiteBalanceMode = {KUidECamEventCameraSettingWhiteBalanceModeUidValue};
225 /** Timer changed. */
226 static const TUid KUidECamEventCameraSettingTimerInterval = {KUidECamEventCameraSettingTimerIntervalUidValue};
227 /** Timer lapse period. */
228 static const TUid KUidECamEventCameraSettingTimeLapse = {KUidECamEventCameraSettingTimeLapseUidValue};
230 static const TUid KUidECamEventCameraSettingOpticalZoom = {KUidECamEventCameraSettingOpticalZoomUidValue};
231 /** Optical zoom range. */
232 static const TUid KUidECamEventCameraSettingOpticalZoomRange = {KUidECamEventCameraSettingOpticalZoomRangeUidValue};
234 static const TUid KUidECamEventCameraSettingDigitalZoom = {KUidECamEventCameraSettingDigitalZoomUidValue};
235 /** Digital zoom range. */
236 static const TUid KUidECamEventCameraSettingDigitalZoomRange = {KUidECamEventCameraSettingDigitalZoomRangeUidValue};
237 /** Clicking sound state. */
238 static const TUid KUidECamEventSoundClick = {KUidECamEventSoundClickUidValue};
239 /** Pixel aspect ratio. */
240 static const TUid KUidECamEventPixelAspectRatio = {KUidECamEventPixelAspectRatioUidValue};
242 static const TUid KUidECamEventYuvRange = {KUidECamEventYuvRangeUidValue};
244 static const TUid KUidECamEventBurstImages = {KUidECamEventBurstImagesUidValue};
245 /** Stabilization effect - magnitude of stabilization */
246 static const TUid KUidECamEventCameraSettingsStabilizationEffect = {KUidECamEventCameraSettingsStabilizationEffectUidValue};
247 /** Stabilization algorithm */
248 static const TUid KUidECamEventSettingsStabilizationAlgorithmComplexity = {KUidECamEventSettingsStabilizationAlgorithmComplexityUidValue};
249 /** Continuous Autofocus timeout */
250 static const TUid KUidECamEventCameraSettingsContinuousAutoFocusTimeout = {KUidECamEventCameraSettingsContinuousAutoFocusTimeoutUidValue};
251 /** White Balance manual setting */
252 static const TUid KUidECamEventCameraSettingsWBValue = {KUidECamEventCameraSettingsWBValueUidValue};
254 static const TUid KUidECamEventFlashReady = {KUidECamEventFlashReadyUidValue};
255 /** Flash not ready */
256 static const TUid KUidECamEventFlashNotReady = {KUidECamEventFlashNotReadyUidValue};
258 This is the new UID value to notify change on focus range and takes immediate effect as previous UID KUidECamEventCameraSettingFocusRange has been deprecated.
259 @see KUidECamEventCameraSettingFocusRange */
260 static const TUid KUidECamEventCameraSettingFocusRange2 = {KUidECamEventCameraSettingFocusRange2UidValue};
262 This is the new UID value to notify change on autofocus type and takes immediate effect as previous UID KUidECamEventCameraSettingAutoFocusType has been deprecated.
263 @see KUidECamEventCameraSettingAutoFocusType */
264 static const TUid KUidECamEventCameraSettingAutoFocusType2 = {KUidECamEventCameraSettingAutoFocusType2UidValue};
269 This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():
270 void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;
271 void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;
272 void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;
275 static const TUid KUidECamEventCameraSettingIsoRateType = {KUidECamEventCameraSettingIsoRateTypeUidValue};
278 Reference Screen setting.
280 This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():
281 void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;
282 void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;
283 void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;
286 static const TUid KUidECamEventCameraSettingReferenceScreen = {KUidECamEventCameraSettingReferenceScreenUidValue};
289 Pre Capture Warning indication.
291 This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():
292 void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;
293 void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;
294 void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;
297 static const TUid KUidECamEventCameraSettingAFAssistantLight = {KUidECamEventCameraSettingAFAssistantLightUidValue};
301 class CCameraContinuousZoom;
303 A mixin class to be implemented by the client in order to use the Continuous Zoom API. The callbacks are invoked by the implementation
304 whenever the continuous zoom operations are ready to be notified.
306 @see CCameraContinuousZoom
311 class MContinuousZoomObserver
316 This callback is sent when a new zoom factor is achieved. Client may not receive a callback for every new zoom factor as it is up
317 to the implementation to choose the zoom factors for which it will issue this callback. Should an error occur, this implies that the
318 continuous zoom operation has been stopped.
320 @param aContinuousZoomHandle
321 Reference to CCameraContinuousZoom class object which was used to start the continuous zoom operation.
324 The new zoom factor value, multiplied by KECamFineResolutionFactor, which has been achieved.
327 Appropriate error code.
329 virtual void ContinuousZoomProgress(CCamera::CCameraContinuousZoom& aContinuousZoomHandle, TInt aZoomFactor, TInt aError)=0;
332 Implementation sends this callback when the Continuous Zoom operation has been completed. This callback will be sent when
333 target zoom factor is achieved. This zoom factor may in some cases be less than the target zoom factor due to the complexity
334 of the continuous zoom operation. Once this callback is received, client need not issue StopContinuousZoom() and can call
335 StartContinuousZoom() again.
337 @param aContinuousZoomHandle
338 Reference to CCameraContinuousZoom class object which was used to start the continuous zoom operation.
340 @param aFinalZoomFactor
341 The final zoom factor value once the continuous zoom operation has completed. This zoom factor may in some cases be
342 less than the target zoom factor due to the complexity of the continuous zoom operation.
345 Appropriate error code.
347 virtual void ContinuousZoomCompleted(CCamera::CCameraContinuousZoom& aContinuousZoomHandle, TInt aFinalZoomFactor, TInt aError)=0;
350 Gets a custom interface for future callbacks. This method will be called by the implementation to get a new interface
351 which would support future callbacks.
354 The Uid of the particular interface function required for callbacks.
357 The implementation has to type-cast the retrieved custom interface pointer to the appropriate type.
359 @return The error code.
361 virtual TInt CustomInterface(TUid aInterface, TAny*& aPtrInterface)=0;
366 CCamera advanced settings class exposes an API for controlling individually
367 digital camera advanced settings. These settings directly relate to the
368 image acquisition phase both for still images and video.
370 @note This class is not intended for sub-classing and used to standardise existing
371 varieties of implementations.
373 @note If the class methods leave, the output type parameter value is not guaranteed to be valid.
378 class CCamera::CCameraAdvancedSettings : public CBase
380 /* so can use internal factory functions etc. */
381 friend class CCamera;
385 /** Specifies camera type. */
388 /** Unable to identify. */
389 ECameraUnknown = 0x00,
390 /** Camera is non-detachable from device. Camera is always present. */
391 ECameraOnBoard = 0x01,
392 /** Camera is detachable from device. Camera is not always present. */
393 ECameraPluggable = 0x02
396 /** Specifies stabilization mode of the camera. */
397 enum TStabilizationMode
399 /** Not present or switched off, default */
400 EStabilizationModeOff = 0x00,
401 /** Stabilization only in horizontal direction. */
402 EStabilizationModeHorizontal = 0x01,
403 /** Stabilization only in vertical direction. */
404 EStabilizationModeVertical = 0x02,
405 /** Rotational stabilization. */
406 EStabilizationModeRotation = 0x04,
407 /** Automatic stabilization. */
408 EStabilizationModeAuto = 0x08,
409 /** Manual stabilization. */
410 EStabilizationModeManual = 0x10
413 /** Supported magnitudes of stabilization effect when in manual mode. */
414 enum TStabilizationEffect
416 /** Stabilization effect is off. */
417 EStabilizationOff = 0x00,
418 /** Stabilization effect is automatic, default. */
419 EStabilizationAuto = 0x01,
420 /** Stabilization effect is very small in magnitude. */
421 EStabilizationFine = 0x02,
422 /** Stabilization effect is average in magnitude. */
423 EStabilizationMedium = 0x04,
424 /** Stabilization effect is large in magnitude. */
425 EStabilizationStrong = 0x08
428 /** Supported stabilization algorithms, graded on complexity. */
429 enum TStabilizationAlgorithmComplexity
431 /** Stabilization algorithm selection is automatic, default. */
432 EStabilizationComplexityAuto = 0x00,
433 /** Stabilization algorithm is simple - less precise but fast. */
434 EStabilizationComplexityLow = 0x01,
435 /** Stabilization algorithm is of medium complexity. */
436 EStabilizationComplexityMedium = 0x02,
437 /** Stabilization algorithm is of high complexity. */
438 EStabilizationComplexityHigh = 0x04
441 /** Supported focus modes. */
444 /** Focus mode is unknown. */
445 EFocusModeUnknown = 0x00,
446 /** Focus is automatic, default. */
447 EFocusModeAuto = 0x01,
448 /** Focus is fixed. */
449 EFocusModeFixed = 0x02,
450 /** Focus is manually set. */
451 EFocusModeManual = 0x04
454 /** Supported focus ranges. */
458 EFocusRangeAuto = 0x00,
459 /** Focus operates in close range (macro). */
460 EFocusRangeMacro = 0x01,
461 /** Normal operation. */
462 EFocusRangeNormal = 0x02,
463 /** Extended (tele) operation. */
464 EFocusRangeTele = 0x04,
465 /** Focus at larger areas at short to medium distance. */
466 EFocusRangePortrait = 0x08,
467 /** Optimised macro operation,
468 where depth of field is very shallow and observation area changes quickly. */
469 EFocusRangeSuperMacro = 0x10,
471 All objects at distances from half of the hyperfocal distance out to infinity will be in focus.
472 This gives gives maximum depth of field.
474 This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
475 CCamera::NewDuplicate2L().
478 EFocusRangeHyperfocal = 0x20,
480 When there is a near obstacle or better focus wanted for far away objects.
482 This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
483 CCamera::NewDuplicate2L().
486 EFocusRangeInfinite = 0x40
489 /** Specifies the supported autofocus types. */
492 /** Autofocus is switched off. */
493 EAutoFocusTypeOff = 0x00,
494 /** Operates on a single shot, consumes less power. */
495 EAutoFocusTypeSingle = 0x01,
496 /** Continious autofocus, more precise but consumes more power.
497 also known as AF Servo. */
498 EAutoFocusTypeContinuous = 0x02
501 /** Specifies the autofocus area. */
504 /** Automatic. Default value */
505 EAutoFocusTypeAuto = 0x00,
506 /** Single area, suitable for relatively flat surfaces and portrait. */
507 EAutoFocusTypeSingleArea = 0x01,
508 /** Multiple points of an object, more weighting for centre points. */
509 EAutoFocusTypeMultiAreaCentered = 0x02
512 /** Specifies the Metering mode for the camera.
513 EMeteringModeAuto is the default value. */
516 /** Automatic mode, default. */
517 EMeteringModeAuto = 0x0000,
518 /** Metering in which the center is given a weighted priority. */
519 EMeteringModeCenterWeighted = 0x0001,
520 /** Metering of a central area/spot only, also known as partial. */
521 EMeteringModeSpot = 0x0002,
522 /** Metering is evaluated over a matrix(several spots) and calculated
523 as a function of that. Usually best but with increased
524 power consumption. Alternative name multi-metering mode. */
525 EMeteringModeEvaluative = 0x0004
528 /** Specifies the drive mode for the camera. This determines how and in what sucession are images
529 shot. EDriveModeSingleShot is the default.*/
532 /** Automatic. Default */
533 EDriveModeAuto = 0x0000,
534 /** Camera takes a single image/shot. */
535 EDriveModeSingleShot = 0x0001,
536 /** Camera continuously captures images (as fast as it can) until stopped or out of storage medium. */
537 EDriveModeContinuous = 0x0002,
538 /** Camera is in bracketing mode, producing individual frames. @see TBracketMode */
539 EDriveModeBracket = 0x0004,
540 /** Camera is in bracketing mode, but producing a single image. @see TBracketMode */
541 EDriveModeBracketMerge = 0x0008,
542 /** camera captures a single shot after specified time period. @see Timer() */
543 EDriveModeTimed = 0x0010,
544 /** Camera captures a set of images with an uniform interval between them. @see TimeLapse() */
545 EDriveModeTimeLapse = 0x0020,
546 /** Camera captures a set of images as fast as it can, but in batches(bursts). */
547 EDriveModeBurst = 0x0040,
548 /** Camera captures a set of images before and after camera capture key press event. Client can specify
549 the amount of pre-capture and post-capture images to be saved via TDriveModeDependentAttributes.
550 The total amount of images to be saved will be pre-capture images + 1 + post-capture images.
552 @note This drive mode is only available to clients using the CCamera::New2L() or CCamera::NewDuplicate2L()
553 in addition to the new image capture APIs ie. CCameraPreImageCaptureControl, CCameraImageCapture and
554 CCameraPostImageCaptureControl.
559 EDriveModeTimeNudgeCapture = 0x0080
562 /** Specifies Bracket mode. */
565 /** Bracket mode is switched off. Default value. */
566 EBracketModeOff = 0x0000,
567 /** Bracket mode on. Three consecutive pictures are taken in order
568 under (-1), on (0), over (+1), where correction magnitude
569 is defined by bracket step size and by TBracketParameter
571 @see TBracketParameter */
572 EBracketMode3Image = 0x0001,
573 /** Bracket mode on. Five consecutive pictures are taken in order
574 under (-2),under (-1), on (0), over (+1), over (+2), where correction magnitude
575 is defined by bracket step size and by TBracketParameter
577 @see TBracketParameter */
578 EBracketMode5Image = 0x0002
581 /** Supported parameters used for bracketing.
582 @note Bracket mode parameter value changes by
583 a selected uniform step between successive image shots.
585 @see TBracketMode. */
586 enum TBracketParameter
589 EBracketParameterNone = 0x0000,
590 /** Exposure settings change. */
591 EBracketParameterExposure = 0x0001,
592 /** Flash power change. */
593 EBracketParameterFlashPower = 0x0002,
594 /** Colour balance settings change. */
595 EBracketParameterColourBalance = 0x0004,
596 /** Aperture settings change. */
597 BracketParameterAperture = 0x0008,
598 /** Autofocus settings change. */
599 BracketParameterAutoFocus = 0x0010
602 /** Specifies the magnitude of bracketing step.
603 The actual value and availability is parameter dependent.
604 @see TBracketParameter
608 /** Not supported. */
609 EBracketStepNonConfig = 0x00,
611 EBracketStepSmall = 0x01,
613 EBracketStepMedium = 0x02,
615 EBracketStepLarge = 0x04
618 /** Specifies the orientation of the picture. */
619 enum TPictureOrientation
621 /** No information about picture orientation. */
622 EPictureOrientationUnknown = 0x00,
623 /** Portrait - height larger than width. */
624 EPictureOrientationPortrait = 0x01,
625 /** Landscape width larger than height. */
626 EPictureOrientationLandscape = 0x02,
627 /** Square width equals the height. */
628 EPictureOrientationSquare = 0x04
631 /** Specifies the pixel aspect ratio
632 @note It is specified as a fraction of
633 (x) horizontal pixel size divided by vertical (y) pixel size.
634 The pixel aspect ratio for square pixels is 1/1.
636 enum TPixelAspectRatio
638 /** Pixel ratio undetermined */
639 EPixelAspectUnknown = 0x00,
640 /** Pixel Ratio 1:1. */
641 EPixelAspect1To1 = 0x01,
642 /** Pixel Ratio 12:11 */
643 EPixelAspect12To11 = 0x02,
644 /** Pixel Ratio 11:10. */
645 EEPixelAspect11To10 = 0x04,
646 /** Pixel Ratio 59:54. */
647 EEPixelAspect59To54 = 0x08,
648 /** Pixel Ratio 16:11.
649 @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()
651 EEPixelAspect16To11 = 0x10,
652 /** Pixel Ratio 10:11.
653 @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()
655 EEPixelAspect10To11 = 0x20,
656 /** Pixel Ratio 40:33.
657 @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()
659 EEPixelAspect40To33 = 0x40
662 /** Specifies YUV colour space dynamic range.
663 @note video compressors often use narrower than the default range.
664 The nominal Y range is [16:235] and the U and V ranges [16:240].
668 /** Yuv range undetermined */
669 EYuvRangeUnknown = 0x00,
670 /** Yuv Full Range. The nominal Y,U and V colours range is [0:255]. */
671 EYuvRangeFull = 0x01,
672 /** Yuv Cropped Range. The nominal Y range is [16:235] and the U and V ranges [16:240]. */
673 EYuvRangeVideoCropped = 0x02
676 /** Specifies the units supported by the camera for manual white balance setting.
680 /** The units type is undetermined or not supported. */
682 /** The white balance is represented as temperature degrees in Kelvin. */
684 /** The white balance is represented as RGB triples. */
689 Specifies the ISO type supported by the camera. ISO refers to the sensivity of the
690 image sensor and is one of the factors influencing the exposure.
695 /** ISO Not supported. Camera uses a fixed ISO rate internally and never reveals this information. */
697 /** Camera gives a list of manual ISO rates to the user to set. Recommendation is to start camera in the manual ISO mode, by default. */
699 /** Camera chooses the ISO on its own without prioritising any particular exposure parameters. */
700 EISOAutoUnPrioritised = 0x02,
701 /** Camera chooses the ISO on its own by prioritising ISO. */
702 EISOAutoISOPrioritised = 0x04,
703 /** Camera chooses the ISO on its own after prioritising shutter speed. */
704 EISOAutoShutterSpeedPrioritised = 0x08,
705 /** Camera chooses the ISO on its own after prioritising aperture opening. */
706 EISOAutoAperturePrioritised = 0x10
710 Specifies the unfavourable circumstances as pre capture warnings which may be issued before image/video capture.
713 enum TPreCaptureWarning
717 /** warning to indicate that camera sensor is over exposed */
718 EPCWOverExposure = 0x0001,
719 /** warning to indicate that camera sensor is under exposed */
720 EPCWUnderExposure = 0x0002,
721 /** warning to indicate that camera operates under insufficient lightning conditions */
722 EPCWLowLight = 0x0004,
723 /** warning to indicate that focussing is not optimum. This is valid for manual/fixed focus only */
724 EPCWBadFocus = 0x0008,
725 /** warning to indicate that camera might not be firmly gripped (Tripod required). This is same as long exposure */
726 EPCWHandShakePossible = 0x0010,
727 /** warning to indicate that camera has not enough power to survive the flash operations (battery discharged) */
728 EPCWNotEnoughPowerForFlash = 0x0020,
729 /** warning to indicate that the current white balance is not the desired one */
730 EPCWWrongWhiteBalanceValue = 0x0040,
731 /** warning to indicate that the current flash value is not the desired one */
732 EPCWWrongFlashValue = 0x0080,
733 /** warning to indicate that the current digital zoom value is not the desired one */
734 EPCWWrongDigiZoomValue = 0x0100,
735 /** warning to indicate that the desired digital zoom affects the quality of image */
736 EPCWDigiZoomBadQuality = 0x0200,
737 /** warning to indicate that flash is not ready. Recommendation: user may subscribe for this warning or issue
738 IsFlashReady() also. Using both options is not encouraged */
739 EPCWFlashNotReady = 0x0400,
740 /** unknown reason */
741 EPCWGeneralWarning = 0x0800,
742 /** warning to indicate that flash has been overheated.
744 @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()
749 EPCWFlashOverheated = 0x1000,
750 /** warning to indicate that flash will not be fired because of enough ambient light.
752 @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()
757 EPCWFlashNotNeeded = 0x2000
761 Describes the camera mode.
766 /** Camera is Idle */
768 /** DSA based Viewfinder runs */
769 EModeDSAViewFinder = 0x01,
770 /** Client based Viewfinder runs */
771 EModeClientViewFinder = 0x02
775 Specifies the different types of auto focus assistant light
777 enum TAFAssistantLight
779 /** switch off the AF assistant light from either of 'manual on' or 'auto' mode */
780 EAFAssistantLightOff = 0x00,
781 /** switch on the AF assistant light manually */
782 EAFAssistantLightManualOn = 0x01,
783 /** Put the AF assistant light in auto mode. It will be automatically decided when to switch on or off. */
784 EAFAssistantLightAuto = 0x02
788 Specifies the different types of continuous zoom supported.
789 The enumeration list may be extended in future.
794 enum TContinuousZoomType
796 /** Continuous zoom not supported */
797 EContinuousZoomNotSupported = 0x00,
798 /** Continuous zoom 'Optical' only, No 'Digital' */
799 EContinuousZoomOpticalOnly = 0x01,
800 /** Continuous zoom 'Optical' and 'Digital' */
801 EContinuousZoomMixed = 0x02,
802 /** Continuous zoom 'Digital' only, No 'Optical' */
803 EContinuousZoomDigitalOnly = 0x04
807 Specifies the zoom direction for continuous zoom operation.
808 The enumeration list may be extended in future.
815 /** Implies that feature not supported. */
816 EZoomDirectionNone =0x00,
817 /** Implies zooming out. */
818 EZoomDirectionWide =0x01,
819 /** Implies zooming in. */
820 EZoomDirectionTele =0x02
824 Different levels for performance vectors like speed, quality, low memory consumption and low power consumption.
825 The enumeration list may be extended in future.
830 enum TPerformanceLevel
832 /** High level preference. */
834 /** Medium level preference. */
836 /** Low level preference. */
838 /** Dont care (No preference). */
843 Specifies flicker removal options.
844 The enumeration list may be extended in future.
850 /** Not Supported. */
851 EFlickerRemovalNone = 0x00,
852 /** Flicker removal for Field frequency of 50Hz. */
853 EFlickerRemoval50Hz = 0x01,
854 /** Flicker removal for Field frequency of 60Hz. */
855 EFlickerRemoval60Hz = 0x02,
856 /** Auto flicker removal. */
857 EFlickerRemovalAuto = 0x04,
858 /** Switch Off flicker removal. */
859 EFlickerRemovalSwitchOff = 0x08
863 Specifes the type of neutral density filters available.
864 The enumeration list may be extended in future.
870 /** Not Supported. */
871 ENDFilterNone = 0x00,
872 /** Auto ND Filter. */
873 ENDFilterAuto = 0x01,
874 /** Switched off ND Filter. */
875 ENDFilterSwitchedOff = 0x02,
876 /** High level ND Filter. */
877 ENDFilterHigh = 0x04,
878 /** Medium level ND Filter. */
879 ENDFilterMedium = 0x08,
880 /** Low level ND Filter. */
882 /** General ND Filter. */
883 ENDFilterGeneral = 0x20
887 Specifies the various events for which the LED effects could be used.
888 The enumeration list may be extended in future.
894 /** Not supported. */
895 ELEDEventNone = 0x00,
896 /** LED effect needed for self timer. */
897 ELEDEventSelfTimer = 0x01,
898 /** LED effect needed for starting of viewfinder. */
899 ELEDEventViewfinderStart = 0x02,
900 /** LED effect needed for stoping of viewfinder. */
901 ELEDEventViewfinderStop = 0x04,
902 /** LED effect needed for still image capture. */
903 ELEDEventStillImageCapture = 0x08,
904 /** LED effect needed for video recording. */
905 ELEDEventVideoRecording = 0x10
909 Specifes the type of LED effects available.
910 The enumeration list may be extended in future.
916 /** Not supported. */
917 ELEDEffectNone =0x00,
918 /** LED always on. */
919 ELEDEffectHardwired =0x01,
921 ELEDEffectAuto =0x02,
922 /** LED Effect manually switched on. */
923 ELEDEffectManualSwitchOn =0x04,
924 /** LED Effect switched off. */
925 ELEDEffectSwitchOff =0x08,
926 /** LED Custom Effect. */
927 ELEDEffectCustom =0x10
931 Color channels on which manual gain can be selectively applied.
932 The enumeration list may be extended in future.
938 /** Red Color Channel (RGB model). */
940 /** Green Color Channel (RGB model). */
942 /** Blue Color Channel (RGB model). */
944 /** Luminance Y component (YUV model). */
946 /** Chrominance U component (YUV model). */
948 /** Chrominance V component (YUV model). */
953 Class used to provide a particular custom LED effect.
957 class TECamLEDSpecialEffectStep
960 TECamLEDSpecialEffectStep();
963 TUint Version() const;
966 //for future expansion
970 // reserved for future expansion.
976 /** Blinking frequency of LED in Hertz. */
977 TUint iBlinkingFrequency;
978 /** Represents the intensity of LED in millicandela. */
980 /** Frequency step with which the blinking frequency changes with time. May be positive as well as negative. */
982 /** Time duration for which the particular LED special effect step would be valid. */
983 TTimeIntervalMicroSeconds32 iDuration;
987 Class used to provide supported continuous zoom information.
992 class TContinuousZoomSupportInfo
995 IMPORT_C TContinuousZoomSupportInfo();
997 IMPORT_C TUint Size() const;
998 IMPORT_C TUint Version() const;
1001 //for future expansion
1005 // reserved for future expansion
1011 /** Maximum continuous zoom speed supported. Minimum speed is 0. */
1012 TInt iMaxSpeedSupported;
1013 /** Minimum continuous zoom acceleration supported. A negative value signifies deceleration. */
1014 TInt iMinAccelerationSupported;
1015 /** Maximum continuous zoom acceleration supported. */
1016 TInt iMaxAccelerationSupported;
1017 /** Minimum continuous zoom value. For digital zoom, this could be 0 unless viewfinder frames are not cropped and scaled up by default.
1018 Represented as a concrete value multiplied by KECamFineResolutionFactor. */
1019 TInt iContinuousZoomMinLimit;
1020 /** Maximum continuous zoom value. Represented as a concrete value multiplied by KECamFineResolutionFactor. */
1021 TInt iContinuousZoomMaxLimit;
1025 Class used to provide essential parameters for continuous zoom operation.
1030 class TContinuousZoomParameters
1033 IMPORT_C TContinuousZoomParameters();
1035 IMPORT_C TUint Size() const;
1036 IMPORT_C TUint Version() const;
1039 //for future expansion
1043 // reserved for future expansion
1049 /** Type of continuous zoom to be used. */
1050 TContinuousZoomType iContinuousZoomType;
1051 /** Zoom direction to be used. */
1052 TZoomDirection iZoomDirection;
1053 /** Continuous zoom speed to be used. Represented as a concrete value multiplied by KECamFineResolutionFactor. */
1054 TInt iContinuousZoomSpeed;
1055 /** Continuous zoom acceleration to be used. Represented as a concrete value multiplied by KECamFineResolutionFactor. */
1056 TInt iContinuousZoomAcceleration;
1057 /** Limit of continuous zoom range. Represented as a concrete value multiplied by KECamFineResolutionFactor. */
1058 TInt iContinuousZoomLimit;
1063 IMPORT_C static CCameraAdvancedSettings* NewL(CCamera& aCamera);
1065 IMPORT_C TCameraType CameraType() const;
1067 IMPORT_C TCameraType CameraType(TInt aCameraIndex);
1069 IMPORT_C TBool IsCameraPresent() const;
1071 IMPORT_C TBool IsCameraPresent(TInt aCameraIndex);
1073 IMPORT_C TInt CameraIndex() const;
1075 IMPORT_C TInt SupportedStabilizationModes() const;
1077 IMPORT_C TStabilizationMode StabilizationMode() const;
1079 IMPORT_C void SetStabilizationMode(TStabilizationMode aStabilizationMode);
1081 IMPORT_C TInt SupportedFocusModes() const;
1083 IMPORT_C TFocusMode FocusMode() const;
1085 IMPORT_C void SetFocusMode(TFocusMode aFocusMode);
1087 IMPORT_C TInt SupportedFocusRanges() const;
1089 IMPORT_C TFocusRange FocusRange() const;
1091 IMPORT_C void SetFocusRange(TFocusRange aFocusRange);
1093 IMPORT_C TInt SupportedAutoFocusTypes() const;
1095 IMPORT_C TAutoFocusType AutoFocusType() const;
1097 IMPORT_C void SetAutoFocusType(TAutoFocusType aAutoFocusType);
1099 IMPORT_C TInt SupportedAutoFocusAreas() const;
1101 IMPORT_C TAutoFocusArea AutoFocusArea() const;
1103 IMPORT_C void SetAutoFocusArea(TAutoFocusArea aAutoFocusArea);
1105 IMPORT_C TInt FocusDistance() const;
1107 IMPORT_C void SetFocusDistance(TInt aDistance);
1109 IMPORT_C TInt GetMinFocalLength() const;
1111 IMPORT_C void GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const;
1113 IMPORT_C TInt IsoRate() const;
1115 IMPORT_C void SetIsoRate(TInt aRate);
1117 IMPORT_C void GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const;
1119 IMPORT_C TInt Aperture() const;
1121 IMPORT_C void SetAperture(TInt aFStop);
1123 IMPORT_C void GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const;
1125 IMPORT_C TInt ShutterSpeed() const;
1127 IMPORT_C void SetShutterSpeed(TInt aShutterSpeed);
1129 IMPORT_C TInt SupportedMeteringModes() const;
1131 IMPORT_C TMeteringMode MeteringMode() const;
1133 IMPORT_C void SetMeteringMode(TMeteringMode aMeteringMode);
1135 IMPORT_C TInt SupportedDriveModes() const;
1137 IMPORT_C TDriveMode DriveMode() const;
1139 IMPORT_C void SetDriveMode(TDriveMode aDriveMode);
1141 IMPORT_C TInt SupportedBracketModes() const;
1143 IMPORT_C TBracketMode BracketMode() const;
1145 IMPORT_C void SetBracketMode(TBracketMode aBracketMode);
1147 IMPORT_C TInt SupportedBracketParameters() const;
1149 IMPORT_C TBracketParameter BracketParameter() const;
1151 IMPORT_C void SetBracketParameter(TBracketParameter aBracketParameter);
1153 IMPORT_C TInt SupportedBracketSteps() const;
1155 IMPORT_C TBracketStep BracketStep() const;
1157 IMPORT_C void SetBracketStep(TBracketStep aBracketStep);
1159 IMPORT_C void GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const;
1161 IMPORT_C void SetBracketMerge(TInt aStartIndex, TInt aFrames);
1163 IMPORT_C TInt SupportedFlashModes() const;
1165 IMPORT_C CCamera::TFlash FlashMode() const;
1167 IMPORT_C void SetFlashMode(CCamera::TFlash aMode);
1169 IMPORT_C TBool RedEyeReduceOn() const;
1171 IMPORT_C void SetRedEyeReduceOn(TBool aState);
1173 IMPORT_C void GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const;
1175 IMPORT_C TInt FlashCompensationStep() const;
1177 IMPORT_C TInt GetFlashCompensationStep(TInt& aFlashCompensationStep) const;
1179 IMPORT_C void SetFlashCompensationStep(TInt aFlashCompensationStep);
1181 IMPORT_C void GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const;
1183 IMPORT_C TInt FlashCompensation() const;
1185 IMPORT_C TInt GetFlashCompensation(TInt& aFlashCompensation) const;
1187 IMPORT_C void SetFlashCompensation(TInt aFlashCompensationInSteps);
1189 IMPORT_C TBool IsExternalFlashPresent() const;
1191 IMPORT_C void GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const;
1193 IMPORT_C TInt ManualFlashPowerLevel() const;
1195 IMPORT_C void SetManualFlashPowerLevel(TInt aManualFlashPowerLevel);
1197 IMPORT_C TInt SupportedExposureModes() const;
1199 IMPORT_C CCamera::TExposure ExposureMode() const;
1201 IMPORT_C void SetExposureMode(CCamera::TExposure aExposureMode);
1203 IMPORT_C void GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const;
1205 IMPORT_C TInt ExposureCompensationStep() const;
1207 IMPORT_C TInt GetExposureCompensationStep(TInt& aExposureCompensationStep) const;
1209 IMPORT_C void SetExposureCompensationStep(TInt aExposureCompensationStep);
1211 IMPORT_C void GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const;
1213 IMPORT_C TInt ExposureCompensation() const;
1215 IMPORT_C TInt GetExposureCompensation(TInt& aExposureCompensation) const;
1217 IMPORT_C void SetExposureCompensation(TInt aExposureCompensationInSteps);
1219 IMPORT_C TInt SupportedWhiteBalanceModes() const;
1221 IMPORT_C CCamera::TWhiteBalance WhiteBalanceMode() const;
1223 IMPORT_C void SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode);
1225 IMPORT_C TBool ApertureExposureLockOn() const;
1227 IMPORT_C void SetApertureExposureLockOn(TBool aAELock);
1229 IMPORT_C TBool ShootClickOn() const;
1231 IMPORT_C void SetShootClickOn(TBool aShootClickOn);
1233 IMPORT_C void GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const;
1235 IMPORT_C TInt TimerInterval() const;
1237 IMPORT_C void SetTimerInterval(TInt aTimerInterval);
1239 IMPORT_C void GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const;
1241 IMPORT_C void GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const;
1243 IMPORT_C void SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval);
1245 IMPORT_C TPictureOrientation PictureOrientation() const;
1247 IMPORT_C void SetPictureOrientation(TPictureOrientation aOrientation);
1249 IMPORT_C TInt SupportedPixelAspectRatios() const;
1251 IMPORT_C TPixelAspectRatio PixelAspectRatio() const;
1253 IMPORT_C void SetPixelAspectRatio(TPixelAspectRatio aPixelAspectRatio);
1255 IMPORT_C TInt SupportedYuvRanges() const;
1257 IMPORT_C TYuvRange YuvRange() const;
1259 IMPORT_C void SetYuvRange(TYuvRange aYuvRange);
1261 IMPORT_C TInt BurstImages() const;
1263 IMPORT_C void SetBurstImages(TInt aImages);
1265 IMPORT_C void GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const;
1267 IMPORT_C TInt OpticalZoom() const;
1269 IMPORT_C void SetOpticalZoom(TInt aOpticalZoom);
1271 IMPORT_C void GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo) const;
1273 IMPORT_C TInt DigitalZoom() const;
1275 IMPORT_C void SetDigitalZoom(TInt aDigitalZoom);
1277 IMPORT_C TBool ExposureLockOn() const;
1279 IMPORT_C void SetExposureLockOn(TBool aState);
1281 IMPORT_C TBool AutoFocusLockOn() const;
1283 IMPORT_C void SetAutoFocusLockOn(TBool aState);
1285 IMPORT_C void GetSupportedSettingsL(RArray<TUid>& aSettings) const;
1287 IMPORT_C void GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;
1289 IMPORT_C void GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;
1291 IMPORT_C TBool AutomaticSizeSelectionChangeOn() const;
1293 IMPORT_C void SetAutomaticSizeSelectionChangeOn(TBool aSetOn);
1295 IMPORT_C void GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const;
1297 IMPORT_C TInt ContinuousAutoFocusTimeout() const;
1299 IMPORT_C void SetContinuousAutoFocusTimeout(TInt aTimeout);
1301 IMPORT_C TInt SupportedStabilizationEffects() const;
1303 IMPORT_C TStabilizationEffect StabilizationEffect() const;
1305 IMPORT_C void SetStabilizationEffect(TStabilizationEffect aEffect);
1307 IMPORT_C TInt SupportedStabilizationComplexityValues() const;
1309 IMPORT_C TStabilizationAlgorithmComplexity StabilizationComplexity() const;
1311 IMPORT_C void SetStabilizationComplexity(TStabilizationAlgorithmComplexity aComplexity);
1313 IMPORT_C TWBUnits SupportedWBUnits() const;
1315 IMPORT_C void GetWBRgbValue(TRgb& aValue) const;
1317 IMPORT_C void SetWBRgbValue(const TRgb& aValue);
1319 IMPORT_C void GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const;
1321 IMPORT_C TInt WBColorTemperature() const;
1323 IMPORT_C void SetWBColorTemperature(TInt aWBColorTemperature);
1325 IMPORT_C ~CCameraAdvancedSettings();
1327 IMPORT_C TInt IsFlashReady(TBool& aReady) const;
1329 IMPORT_C void GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const;
1331 IMPORT_C void GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const;
1333 IMPORT_C void SetISORateL(TISORateType aISORateType, TInt aParam);
1335 IMPORT_C void GetISORateL(TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const;
1337 IMPORT_C void SetReferenceScreenL(CWsScreenDevice& aScreenDevice);
1339 IMPORT_C void GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aSizeIndex,
1340 CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const;
1342 IMPORT_C void GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aFrameRateIndex,
1343 TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible, CCamera::TExposure aExposure) const;
1345 IMPORT_C void GetPreCaptureWarningSupportedL(TCameraMode aCameraMode, TInt& aPreCaptureWarningSupported) const;
1347 IMPORT_C void SubscribeToPreCaptureWarningL(TInt aPreCaptureWarning);
1349 IMPORT_C void UnSubscribePreCaptureWarningL();
1351 IMPORT_C void GetPreCaptureWarningL(TInt& aPreCaptureWarning) const;
1353 IMPORT_C void GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const;
1355 IMPORT_C void GetAFAssistantLightL(TAFAssistantLight& aAFAssistantLight) const;
1357 IMPORT_C void SetAFAssistantLightL(TAFAssistantLight aAFAssistantLight);
1359 IMPORT_C void GetSupportedContinuousZoomTypeL(TUint& aSupportedContinuousZoomType) const;
1361 IMPORT_C void GetFocalLengthInfoL(TInt& aMinFocalLength, TInt& aCurrentFocalLength, TInt& aMaxFocalLength) const;
1363 IMPORT_C void GetNumOperationPreferenceL(TUint& aNumOperationPreferenceSupported) const;
1365 IMPORT_C void EnumerateOperationPreferenceL(TUint aOperationPreferenceIndex, TPerformanceLevel& aSpeedLevel,
1366 TPerformanceLevel& aQualityLevel, TPerformanceLevel& aLowMemoryConsumptionLevel,
1367 TPerformanceLevel& aLowPowerConsumptionLevel) const;
1369 IMPORT_C void SetOperationPreferenceL(TUint aOperationPreferenceIndex);
1371 IMPORT_C void GetOperationPreferenceL(TInt& aOperationPreferenceIndex) const;
1373 IMPORT_C void GetSupportedEventsL(RArray<TUid>& aSupportedEvents) const;
1375 IMPORT_C void GetIndirectFeatureChangesL(TUid aRequestedSetting, RArray<TUid>& aIndirectFeatureChanges) const;
1377 IMPORT_C void CreateContinuousZoomL(MContinuousZoomObserver& aObserver, TContinuousZoomType aContinuousZoomType, CCameraContinuousZoom*& aContinuousZoom);
1380 IMPORT_C CCameraAdvancedSettings(CCamera& aOwner);
1381 IMPORT_C void ConstructL();
1384 enum TECAMEventFilterScheme
1386 /** Black listing will mean not to receive specific events */
1387 EECAMEventFilterSchemeBlackList,
1388 /** White listing will mean to receive only specific events */
1389 EECAMEventFilterSchemeWhiteList
1392 void RegisterEventsL(TECAMEventFilterScheme aEventFilter, const RArray<TUid>& aEvents);
1393 void GetRegisterEventsL(TECAMEventFilterScheme aEventFilter, RArray<TUid>& aEvents, TValueInfo& aInfo) const;
1395 void GetSupportedFlickerRemovalValueL(TUint& aSupportedFlickerRemovalValue) const;
1396 void GetFlickerRemovalValueL(TFlickerRemoval& aFlickerRemovalValue) const;
1397 void SetFlickerRemovalValueL(TFlickerRemoval aFlickerRemovalValue);
1399 void GetSupportedNDFilterL(TUint& aSupportedNDFilter) const;
1400 void GetNDFilterL(TNDFilter& aNDFilter) const;
1401 void SetNDFilterL(TNDFilter aNDFilter);
1403 void GetLEDEffectL(TLEDEvent aLEDEvent, TLEDEffect& aLEDEffect) const;
1404 void SetLEDEffectL(TLEDEvent aLEDEvent, TLEDEffect aLEDEffect);
1405 void SetLEDCustomEffectL(TLEDEvent aLEDEvent, const RArray<TECamLEDSpecialEffectStep>& aLEDSpecialEffectSteps);
1407 void ReserveL(const TTimeIntervalMicroSeconds32& aMaxTimeToWait, TBool aKickOut);
1408 void SetClientPriorityL(TInt aPriority);
1409 void RestoreClientPriorityL();
1411 void GetSupportedManualGainL(RArray<TInt>& aSupportedManualGain, TColorChannel aColorChannel) const;
1412 void GetManualGainL(TInt& aManualGain, TColorChannel aColorChannel) const;
1413 void SetManualGainL(TInt aManualGain, TColorChannel aColorChannel);
1415 void SetWhiteBalanceLockL(TBool aEnableLock);
1416 void GetWhiteBalanceLockStateL(TBool& aIsLocked) const;
1418 void EnableStateSavingL(RWriteStream& aLatestCameraState);
1419 void DisableStateSavingL();
1420 void RestoreLatestStateL(RReadStream& aLatestCameraState);
1421 void SaveCameraStateL(RWriteStream& aCustomCameraState);
1422 void DisableCameraStateSavingL(RWriteStream& aCustomCameraState);
1423 void RestoreCameraStateL(RReadStream& aCustomCameraState);
1427 MCameraAdvancedSettings* iImpl; // not owned
1428 MCameraAdvancedSettings2* iImpl2; // not owned
1430 MCameraAdvancedSettings3* iImpl3; // not owned
1432 MCameraAdvancedSettings4* iImpl4; // not owned
1436 Supported presets with the assumption for scope and outcome
1439 /** Default settings */
1440 static const TUid KUidECamPresetFactoryDefault = {KUidECamPresetFactoryDefaultUidValue};
1441 /** Daytime shot with normal exposure time, one shot autofocus,
1442 medium ISO rating and no flash. */
1443 static const TUid KUidECamPresetOutdoor = {KUidECamPresetOutdoorUidValue};
1444 /** Daytime shot with short exposure time, continuous autofocus,
1445 high Iso rating and no flash. */
1446 static const TUid KUidECamPresetOutdoorSport = {KUidECamPresetOutdoorSportUidValue};
1447 /** Daytime shot with very short exposure time, high shutter speed,
1448 high Iso rating and no flash. */
1449 static const TUid KUidECamPresetSnow = {KUidECamPresetSnowUidValue};
1450 /** Daytime shot with very short exposure time, high shutter speed,
1451 high contrast, reflections and no flash. */
1452 static const TUid KUidECamPresetBeach = {KUidECamPresetBeachUidValue};
1453 /** Night time shot with long central exposure time and high flash power. */
1454 static const TUid KUidECamPresetNightPortrait = {KUidECamPresetNightPortraitUidValue};
1455 /** Night time shot with long exposure time and no flash. */
1456 static const TUid KUidECamPresetNightFireworks = {KUidECamPresetNightFireworksUidValue};
1457 /** Daytime shot with medium exposure time, medium to high Iso rating,
1458 overcast daylight, low contrast, fill-in flash. */
1459 static const TUid KUidECamPresetFog = {KUidECamPresetFogUidValue};
1460 /** Fluorescent lightning with medium exposure time,
1461 medium to low shutter speed with flash. */
1462 static const TUid KUidECamPresetIndoor = {KUidECamPresetIndoorUidValue};
1463 /** Fluorescent lightning with continuous autofocus, wide aperture,
1464 high Iso rating with flash. */
1465 static const TUid KUidECamPresetIndoorSport = {KUidECamPresetIndoorSportUidValue};
1467 Used in low light situations. Tries to capture all the photons from a low light scene.
1468 The image may be processed longer to achieve this. This case may cause blurring, but that could be a
1471 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1472 CCamera::NewDuplicate2L().
1475 static const TUid KUidECamPresetNightPartyIndoor = {KUidECamPresetNightPartyIndoorUidValue};
1477 Used to capture images of things which can't be seen by eye.
1478 For example: snowflakes, underwater photography, small insect photos
1480 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1481 CCamera::NewDuplicate2L().
1484 static const TUid KUidECamPresetNightCloseUp = {KUidECamPresetNightCloseUpUidValue};
1486 Used for revealing assumed details. For example: business card photos, small written text photos,
1487 underwater photography, insect photos.
1489 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1490 CCamera::NewDuplicate2L().
1493 static const TUid KUidECamPresetNightMacro = {KUidECamPresetNightMacroUidValue};
1495 Used for taking clear pictures of text or drawings. Also used to capture business cards or of a whiteboard.
1496 Aim is to optimise text and drawing readability and user expectation of "white" paper.
1497 Camera shake may reduce quality in case no flash available or not adequate(distance too much from subject).
1499 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1500 CCamera::NewDuplicate2L().
1503 static const TUid KUidECamPresetTextDocument = {KUidECamPresetTextDocumentUidValue};
1505 Used for providing clear pictures of barcode. Aim is to convert barcode into some form which can be easily decoded.
1506 Camera shake may reduce this barcode readability and hence, barcode conversion accuracy and reliability.
1508 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1509 CCamera::NewDuplicate2L().
1512 static const TUid KUidECamPresetBarcode = {KUidECamPresetBarcodeUidValue};
1514 Used when factory default preset in certain cases may not be available or is too restrictive.
1515 Automatic preset expects the hardware to use automatic detection for most of the features.
1517 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1518 CCamera::NewDuplicate2L().
1521 static const TUid KUidECamPresetAuto = {KUidECamPresetAutoUidValue};
1523 Used for portraits of human subjects in good lighting conditions. Focuses on the people and captures natural
1524 skin tones. Background details may not be softened.
1526 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1527 CCamera::NewDuplicate2L().
1530 static const TUid KUidECamPresetPortrait = {KUidECamPresetPortraitUidValue};
1532 Used for sharp landscape shots with clear outlines, colours and contrast, for example forest, sky.
1533 The main aim is to get the details of the scene.
1535 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1536 CCamera::NewDuplicate2L().
1539 static const TUid KUidECamPresetLandscape = {KUidECamPresetLandscapeUidValue};
1541 Used to retain the ambience/mood produced by, for example, warm lighting conditions like sunset, candlelight etc.
1543 This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or
1544 CCamera::NewDuplicate2L().
1547 static const TUid KUidECamPresetAmbienceMood = {KUidECamPresetAmbienceMoodUidValue};
1550 This API is used to simplify user - camera interaction by allowing simultaneous
1551 setting of various advanced camera hardware settings using a single parameter.
1553 Preset is identified by a single UID and relates to a known predefined outcome.
1554 For example the 'Night' Preset will be used to set the camera into a night mode
1555 so that the user can take night photos.
1557 The particular set of settings associated with the specific preset and their specific values
1558 and ranges are camera hardware specific and outside the scope of this API.
1560 @note This class is not intended for sub-classing and used to standardise existing
1561 varieties of implementations.
1563 @note If the class methods leave, the output type parameter value is not guaranteed to be valid.
1568 class CCamera::CCameraPresets : public CBase
1570 /** allow access to private constructors. */
1571 friend class CCamera;
1575 IMPORT_C static CCameraPresets* NewL(CCamera& aCamera);
1577 IMPORT_C void GetSupportedPresetsL(RArray<TUid>& aPresets) const;
1579 IMPORT_C void SetPreset(TUid aPreset);
1581 IMPORT_C TUid Preset() const;
1583 IMPORT_C void GetAffectedSettingsL(RArray<TUid>& aSettings) const;
1585 IMPORT_C void GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const;
1587 IMPORT_C ~CCameraPresets();
1589 IMPORT_C void GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const;
1591 IMPORT_C void GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const;
1593 IMPORT_C void IsPresetUnlockSupportedL(TBool& aUnlockSupported) const;
1595 IMPORT_C void LockPresetL();
1597 IMPORT_C void UnlockPresetL();
1600 IMPORT_C CCameraPresets(CCamera& aOwner);
1601 IMPORT_C void ConstructL();
1603 void FilterUnrecognisedUids(RArray<TUid>& aUids, const TInt aBaselineUid) const;
1607 MCameraPresets* iImpl; // not owned
1608 MCameraPresets2* iImpl2; // not owned
1613 This API is used to provide advanced continuous zoom support to the user.
1615 This class is not directly created by the client but instead created via
1616 CCameraAdvancedSettings::CreateContinuousZoomL(). Ownership of the object
1617 is passed back to the client.
1619 @note This class is not intended for sub-classing and used to standardise existing
1620 varieties of implementations.
1622 @note If the class methods leave, the output type parameter value is not guaranteed to be valid.
1627 class CCamera::CCameraContinuousZoom : public CBase
1629 friend void CCamera::CCameraAdvancedSettings::CreateContinuousZoomL(MContinuousZoomObserver& aObserver, TContinuousZoomType aContinuousZoomType, CCameraContinuousZoom*& aContinuousZoom);
1632 IMPORT_C void StartContinuousZoomL(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters aContinuousZoomParameters);
1634 IMPORT_C void StopContinuousZoom();
1636 IMPORT_C void GetContinuousZoomSupportInfoL(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo& aContinuousZoomInfo) const;
1638 IMPORT_C void GetContinuousZoomId(TInt& aZoomId) const;
1640 IMPORT_C ~CCameraContinuousZoom();
1643 static CCameraContinuousZoom* CreateL(MContinuousZoomObserver& aObserver, CCamera::CCameraAdvancedSettings::TContinuousZoomType aContinuousZoomType, const MImplementationFactory& aImplFactory);
1645 CCameraContinuousZoom();
1646 void ConstructL(MContinuousZoomObserver& aObserver, CCamera::CCameraAdvancedSettings::TContinuousZoomType aContinuousZoomType, const MImplementationFactory& aImplFactory);
1649 MCameraContinuousZoom* iImpl;
1652 #endif // ECAMADVSETTINGS_H