diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/ecamadvsettings.h --- a/epoc32/include/ecamadvsettings.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/ecamadvsettings.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,1622 @@ -ecamadvsettings.h +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + + + +/** + @file + @publishedAll + @released +*/ +#ifndef ECAMADVSETTINGS_H +#define ECAMADVSETTINGS_H + +#include +#include +#include +#include +#include +#include +#include + +class MCameraPresets; +class MCameraAdvancedSettings; +class MCameraAdvancedSettings2; +class MCameraAdvancedSettings3; +class MCameraAdvancedSettings4; +class MCameraPresets2; + +/* General purpose constants */ + +/** +The current Version of the TECamLEDSpecialEffectStep class. + +@internalTechnology +*/ +static const TUint KECamLEDSpecialEffectStepCurrentVersion = 1; + +/** + UID used to identify the CCamera Advanced Settings API. + This API is used to control specific individual advanced settings of camera hardware. + These settings directly relate to the image acquisition phase. + + @see CCamera::CCameraAdvancedSettings +*/ +static const TUid KECamAdvancedSettingUid = {KECamAdvancedSettingUidValue}; + +/** + UID used to identify the CCamera Presets API. + This API is used to simplify user - camera interaction by allowing simultaneous + setting of various advanced camera hardware settings using a single predefined parameter. + @see CCamera::CCameraPresets +*/ +static const TUid KECamPresetsUid = {KECamPresetsUidValue}; + + +/** All clients receive these events, irrespective of camera index. */ +/** Camera slots in for 8 cameras. */ +/** Camera with index 0 Plugged-in */ +static const TUid KUidECamEventGlobalCamera00PluggedIn = {KUidECamEventGlobalCamera00PluggedInUidValue}; +/** Camera with index 1 Plugged-in */ +static const TUid KUidECamEventGlobalCamera01PluggedIn = {KUidECamEventGlobalCamera01PluggedInUidValue}; +/** Camera with index 2 Plugged-in */ +static const TUid KUidECamEventGlobalCamera02PluggedIn = {KUidECamEventGlobalCamera02PluggedInUidValue}; +/** Camera with index 3 Plugged-in */ +static const TUid KUidECamEventGlobalCamera03PluggedIn = {KUidECamEventGlobalCamera03PluggedInUidValue}; +/** Camera with index 4 Plugged-in */ +static const TUid KUidECamEventGlobalCamera04PluggedIn = {KUidECamEventGlobalCamera04PluggedInUidValue}; +/** Camera with index 5 Plugged-in */ +static const TUid KUidECamEventGlobalCamera05PluggedIn = {KUidECamEventGlobalCamera05PluggedInUidValue}; +/** Camera with index 6 Plugged-in */ +static const TUid KUidECamEventGlobalCamera06PluggedIn = {KUidECamEventGlobalCamera06PluggedInUidValue}; +/** Camera with index 7 Plugged-in */ +static const TUid KUidECamEventGlobalCamera07PluggedIn = {KUidECamEventGlobalCamera07PluggedInUidValue}; + +/** Camera slots plugged out for 8 cameras. */ +/** Camera with index 0 Plugged-out */ +static const TUid KUidECamEventGlobalCamera00PluggedOut = {KUidECamEventGlobalCamera00PluggedOutUidValue}; +/** Camera with index 1 Plugged-out */ +static const TUid KUidECamEventGlobalCamera01PluggedOut = {KUidECamEventGlobalCamera01PluggedOutUidValue}; +/** Camera with index 2 Plugged-out */ +static const TUid KUidECamEventGlobalCamera02PluggedOut = {KUidECamEventGlobalCamera02PluggedOutUidValue}; +/** Camera with index 3 Plugged-out */ +static const TUid KUidECamEventGlobalCamera03PluggedOut = {KUidECamEventGlobalCamera03PluggedOutUidValue}; +/** Camera with index 4 Plugged-out */ +static const TUid KUidECamEventGlobalCamera04PluggedOut = {KUidECamEventGlobalCamera04PluggedOutUidValue}; +/** Camera with index 5 Plugged-out */ +static const TUid KUidECamEventGlobalCamera05PluggedOut = {KUidECamEventGlobalCamera05PluggedOutUidValue}; +/** Camera with index 6 Plugged-out */ +static const TUid KUidECamEventGlobalCamera06PluggedOut = {KUidECamEventGlobalCamera06PluggedOutUidValue}; +/** Camera with index 7 Plugged-out */ +static const TUid KUidECamEventGlobalCamera07PluggedOut = {KUidECamEventGlobalCamera07PluggedOutUidValue}; + +/** Camera slots available for 8 cameras. */ +/** Signals a camera previously has been reserved and then released again. + In this way available clients may attempt to reserve the camera */ +/** Camera with index 0 Available. */ +static const TUid KUidECamEventGlobalCamera00Available = {KUidECamEventGlobalCamera00AvailableUidValue}; +/** Camera with index 1 Available. */ +static const TUid KUidECamEventGlobalCamera01Available = {KUidECamEventGlobalCamera01AvailableUidValue}; +/** Camera with index 2 Available. */ +static const TUid KUidECamEventGlobalCamera02Available = {KUidECamEventGlobalCamera02AvailableUidValue}; +/** Camera with index 3 Available. */ +static const TUid KUidECamEventGlobalCamera03Available = {KUidECamEventGlobalCamera03AvailableUidValue}; +/** Camera with index 4 Available. */ +static const TUid KUidECamEventGlobalCamera04Available = {KUidECamEventGlobalCamera04AvailableUidValue}; +/** Camera with index 5 Available. */ +static const TUid KUidECamEventGlobalCamera05Available = {KUidECamEventGlobalCamera05AvailableUidValue}; +/** Camera with index 6 Available. */ +static const TUid KUidECamEventGlobalCamera06Available = {KUidECamEventGlobalCamera06AvailableUidValue}; +/** Camera with index 7 Available. */ +static const TUid KUidECamEventGlobalCamera07Available = {KUidECamEventGlobalCamera07AvailableUidValue}; + +/** Individual camera events. These are used by the camera to signal its observers. */ +/** Lens changed. */ +static const TUid KUidECamEventLensChanged = {KUidECamEventLensChangedUidValue}; +/** Flash source added. */ +static const TUid KUidECamEventFlashSourceAdded = {KUidECamEventFlashSourceAddedUidValue}; +/** Flash source removed. */ +static const TUid KUidECamEventFlashSourceRemoved = {KUidECamEventFlashSourceRemovedUidValue}; +/** Image resolution changed. */ +static const TUid KUidECamEventCameraSettingImageSize = {KUidECamEventCameraSettingImageSizeUidValue}; +/** Image Format changed. */ +static const TUid KUidECamEventCameraSettingImageFormat = {KUidECamEventCameraSettingImageFormatUidValue}; +/** Camera orientation changed. */ +static const TUid KUidECamEventCameraSettingCameraOrientation = {KUidECamEventCameraSettingCameraOrientationUidValue}; +/** Optimal focus */ +static const TUid KUidECamEventCameraSettingsOptimalFocus = {KUidECamEventCameraSettingsOptimalFocusUidValue}; + +/** Advanced settings. */ +/** Stabilization mode. */ +static const TUid KUidECamEventCameraSettingStabilizationMode = {KUidECamEventCameraSettingStabilizationModeUidValue}; +/** Focus mode. */ +static const TUid KUidECamEventCameraSettingFocusMode = {KUidECamEventCameraSettingFocusModeUidValue}; +/** Focus range. +@deprecated + +Replaced by KUidECamEventCameraSettingFocusRange2 + +In the first release of this event, KUidECamEventCameraSettingFocusRange was incorrectly given an already existing uid. +In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingFocusRange2. +Camera servers predating this API change will continue to send the original event which is indistinguishable by value. +Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed. +Camera servers which have been updated should send both KUidECamEventCameraSettingFocusRange and KUidECamEventCameraSettingFocusRange2 on a focus range change. +Camera clients should therefore process both events(old and new). + +@see KUidECamEventCameraSettingFocusRange2 +*/ +static const TUid KUidECamEventCameraSettingFocusRange = {KUidECamEventCameraSettingFocusRangeUidValue}; +/** Autofocus type. +@deprecated + +Replaced by KUidECamEventCameraSettingAutoFocusType2 + +In the first release of this event, KUidECamEventCameraSettingAutoFocusType was incorrectly given an already existing uid. +In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingAutoFocusType2. +Camera servers predating this API change will continue to send the original event which is indistinguishable by value. +Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed. +Camera servers which have been updated should send both KUidECamEventCameraSettingAutoFocusType and KUidECamEventCameraSettingAutoFocusType2 on a focus range change. +Camera clients should therefore process both events(old and new). + +@see KUidECamEventCameraSettingAutoFocusType2*/ +static const TUid KUidECamEventCameraSettingAutoFocusType = {KUidECamEventCameraSettingAutoFocusTypeUidValue}; +/** Autofocus area. */ +static const TUid KUidECamEventCameraSettingAutoFocusArea = {KUidECamEventCameraSettingAutoFocusAreaUidValue}; +/** Autofocus lock state. */ +static const TUid KUidECamEventCameraSettingAutoFocusLock = {KUidECamEventCameraSettingAutoFocusLockUidValue}; +/** Focus distance */ +static const TUid KUidECamEventCameraSettingFocusDistance = {KUidECamEventCameraSettingFocusDistanceUidValue}; +/** Sensitivity - ISO rate. */ +static const TUid KUidECamEventCameraSettingIsoRate = {KUidECamEventCameraSettingIsoRateUidValue}; +/** Aperture. */ +static const TUid KUidECamEventCameraSettingAperture = {KUidECamEventCameraSettingApertureUidValue}; +/** Aperture range. */ +static const TUid KUidECamEventCameraSettingApertureRange = {KUidECamEventCameraSettingApertureRangeUidValue}; +/** Shutter speed. */ +static const TUid KUidECamEventCameraSettingShutterSpeed = {KUidECamEventCameraSettingShutterSpeedUidValue}; +/** Shutter speed range. */ +static const TUid KUidECamEventCameraSettingShutterSpeedRange = {KUidECamEventCameraSettingShutterSpeedRangeUidValue}; +/** Metering mode. */ +static const TUid KUidECamEventCameraSettingMeteringMode = {KUidECamEventCameraSettingMeteringModeUidValue}; +/** Drive mode. */ +static const TUid KUidECamEventCameraSettingDriveMode = {KUidECamEventCameraSettingDriveModeUidValue}; +/** Braket mode. */ +static const TUid KUidECamEventCameraSettingBracketMode = {KUidECamEventCameraSettingBracketModeUidValue}; +/** Bracket step. */ +static const TUid KUidECamEventCameraSettingBracketStep = {KUidECamEventCameraSettingBracketStepUidValue}; +/** Bracket parameter. */ +static const TUid KUidECamEventCameraSettingBracketParameter = {KUidECamEventCameraSettingBracketParameterUidValue}; +/** Bracket merge. */ +static const TUid KUidECamEventBracketMerge = {KUidECamEventBracketMergeUidValue}; +/** Picture orientation. */ +static const TUid KUidECamEventCameraSettingPictureOrientation = {KUidECamEventCameraSettingPictureOrientationUidValue}; +/** Automatic size selection option */ +static const TUid KUidECamEventCameraSettingAutomaticSizeSelection = {KUidECamEventCameraSettingAutomaticSizeSelectionUidValue}; +/** Flash setting. */ +static const TUid KUidECamEventCameraSettingFlashMode = {KUidECamEventCameraSettingFlashModeUidValue}; +/** Flash compensation step. */ +static const TUid KUidECamEventCameraSettingFlashCompensationStep = {KUidECamEventCameraSettingFlashCompensationStepUidValue}; +/** Flash compensation. */ +static const TUid KUidECamEventCameraSettingFlashCompensation = {KUidECamEventCameraSettingFlashCompensationUidValue}; +/** Manual flash power. */ +static const TUid KUidECamEventCameraSettingFlashManualPower = {KUidECamEventCameraSettingFlashManualPowerUidValue}; +/** Red eye reduce mode. */ +static const TUid KUidECamEventCameraSettingFlashRedEyeReduce = {KUidECamEventCameraSettingFlashRedEyeReduceUidValue}; +/** Exposure mode setting. */ +static const TUid KUidECamEventCameraSettingExposureMode = {KUidECamEventCameraSettingExposureModeUidValue}; +/** Exposure compensation step. */ +static const TUid KUidECamEventCameraSettingExposureCompensationStep = {KUidECamEventCameraSettingExposureCompensationStepUidValue}; +/** Exposure compensation. */ +static const TUid KUidECamEventCameraSettingExposureCompensation = {KUidECamEventCameraSettingExposureCompensationUidValue}; +/** Exposure lock state. */ +static const TUid KUidECamEventCameraSettingExposureLock = {KUidECamEventCameraSettingExposureLockUidValue}; +/** AE lock option. */ +static const TUid KUidECamEventAELock = {KUidECamEventAELockUidValue}; +/** White balance. */ +static const TUid KUidECamEventCameraSettingWhiteBalanceMode = {KUidECamEventCameraSettingWhiteBalanceModeUidValue}; +/** Timer changed. */ +static const TUid KUidECamEventCameraSettingTimerInterval = {KUidECamEventCameraSettingTimerIntervalUidValue}; +/** Timer lapse period. */ +static const TUid KUidECamEventCameraSettingTimeLapse = {KUidECamEventCameraSettingTimeLapseUidValue}; +/** Optical zoom. */ +static const TUid KUidECamEventCameraSettingOpticalZoom = {KUidECamEventCameraSettingOpticalZoomUidValue}; +/** Optical zoom range. */ +static const TUid KUidECamEventCameraSettingOpticalZoomRange = {KUidECamEventCameraSettingOpticalZoomRangeUidValue}; +/** Digital zoom. */ +static const TUid KUidECamEventCameraSettingDigitalZoom = {KUidECamEventCameraSettingDigitalZoomUidValue}; +/** Digital zoom range. */ +static const TUid KUidECamEventCameraSettingDigitalZoomRange = {KUidECamEventCameraSettingDigitalZoomRangeUidValue}; +/** Clicking sound state. */ +static const TUid KUidECamEventSoundClick = {KUidECamEventSoundClickUidValue}; +/** Pixel aspect ratio. */ +static const TUid KUidECamEventPixelAspectRatio = {KUidECamEventPixelAspectRatioUidValue}; +/** Yuv range. */ +static const TUid KUidECamEventYuvRange = {KUidECamEventYuvRangeUidValue}; +/** Burst images. */ +static const TUid KUidECamEventBurstImages = {KUidECamEventBurstImagesUidValue}; +/** Stabilization effect - magnitude of stabilization */ +static const TUid KUidECamEventCameraSettingsStabilizationEffect = {KUidECamEventCameraSettingsStabilizationEffectUidValue}; +/** Stabilization algorithm */ +static const TUid KUidECamEventSettingsStabilizationAlgorithmComplexity = {KUidECamEventSettingsStabilizationAlgorithmComplexityUidValue}; +/** Continuous Autofocus timeout */ +static const TUid KUidECamEventCameraSettingsContinuousAutoFocusTimeout = {KUidECamEventCameraSettingsContinuousAutoFocusTimeoutUidValue}; +/** White Balance manual setting */ +static const TUid KUidECamEventCameraSettingsWBValue = {KUidECamEventCameraSettingsWBValueUidValue}; +/** Flash ready */ +static const TUid KUidECamEventFlashReady = {KUidECamEventFlashReadyUidValue}; +/** Flash not ready */ +static const TUid KUidECamEventFlashNotReady = {KUidECamEventFlashNotReadyUidValue}; +/** Focus range. +This is the new UID value to notify change on focus range and takes immediate effect as previous UID KUidECamEventCameraSettingFocusRange has been deprecated. +@see KUidECamEventCameraSettingFocusRange */ +static const TUid KUidECamEventCameraSettingFocusRange2 = {KUidECamEventCameraSettingFocusRange2UidValue}; +/** Autofocus type. +This is the new UID value to notify change on autofocus type and takes immediate effect as previous UID KUidECamEventCameraSettingAutoFocusType has been deprecated. +@see KUidECamEventCameraSettingAutoFocusType */ +static const TUid KUidECamEventCameraSettingAutoFocusType2 = {KUidECamEventCameraSettingAutoFocusType2UidValue}; + +/** +ISO Rate type. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +*/ +static const TUid KUidECamEventCameraSettingIsoRateType = {KUidECamEventCameraSettingIsoRateTypeUidValue}; + +/** +Reference Screen setting. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +*/ +static const TUid KUidECamEventCameraSettingReferenceScreen = {KUidECamEventCameraSettingReferenceScreenUidValue}; + +/** +Pre Capture Warning indication. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +*/ +static const TUid KUidECamEventCameraSettingAFAssistantLight = {KUidECamEventCameraSettingAFAssistantLightUidValue}; + +/** +Notifies the client that continuous zoom limit has been reached. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventCameraSettingContinuousZoomReachedLimit = {KUidECamEventCameraSettingContinuousZoomReachedLimitUidValue}; + +/** +Notifies the client about the setting of performance operation preference. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventCameraSettingOperationPreference = {KUidECamEventCameraSettingOperationPreferenceUidValue}; + +/** +Notifies the client that the flicker removal value has been set. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@internalTechnology +*/ +static const TUid KUidECamEventCameraSettingFlickerRemovalValue = {KUidECamEventCameraSettingFlickerRemovalValueUidValue}; + +/** +Notifies the client about the setting of neutral density filter. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@internalTechnology +*/ +static const TUid KUidECamEventCameraSettingNDFilter = {KUidECamEventCameraSettingNDFilterUidValue}; + +/** +Notifies the client about the setting of LED effect. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@internalTechnology +*/ +static const TUid KUidECamEventCameraSettingLEDEffect = {KUidECamEventCameraSettingLEDEffectUidValue}; + +/** +Notifies the client about the setting of LED 'custom' effect. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@internalTechnology +*/ +static const TUid KUidECamEventCameraSettingLEDCustomEffect = {KUidECamEventCameraSettingLEDCustomEffectUidValue}; + +/** +Notifies the client about the white balance lock setting. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@internalTechnology +*/ +static const TUid KUidECamEventCameraSettingLockWhiteBalance = {KUidECamEventCameraSettingLockWhiteBalanceUidValue}; + +/** +Instructs the client to restore its original priority. + +This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L(): +void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray& aSettings) const; +void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray& aActiveSettings) const; +void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray& aDisabledSettings) const; + +@internalTechnology +*/ +static const TUid KUidECamEventCameraSettingRestoreClientPriority = {KUidECamEventCameraSettingRestoreClientPriorityUidValue}; + +/** +CCamera advanced settings class exposes an API for controlling individually +digital camera advanced settings. These settings directly relate to the +image acquisition phase both for still images and video. + +@note This class is not intended for sub-classing and used to standardise existing + varieties of implementations. + +@note If the class methods leave, the output type parameter value is not guaranteed to be valid. + +@publishedAll +@released +*/ +class CCamera::CCameraAdvancedSettings : public CBase + { + /* so can use internal factory functions etc. */ + friend class CCamera; + +public: + + /** Specifies camera type. */ + enum TCameraType + { + /** Unable to identify. */ + ECameraUnknown = 0x00, + /** Camera is non-detachable from device. Camera is always present. */ + ECameraOnBoard = 0x01, + /** Camera is detachable from device. Camera is not always present. */ + ECameraPluggable = 0x02 + }; + + /** Specifies stabilization mode of the camera. */ + enum TStabilizationMode + { + /** Not present or switched off, default */ + EStabilizationModeOff = 0x00, + /** Stabilization only in horizontal direction. */ + EStabilizationModeHorizontal = 0x01, + /** Stabilization only in vertical direction. */ + EStabilizationModeVertical = 0x02, + /** Rotational stabilization. */ + EStabilizationModeRotation = 0x04, + /** Automatic stabilization. */ + EStabilizationModeAuto = 0x08, + /** Manual stabilization. */ + EStabilizationModeManual = 0x10 + }; + + /** Supported magnitudes of stabilization effect when in manual mode. */ + enum TStabilizationEffect + { + /** Stabilization effect is off. */ + EStabilizationOff = 0x00, + /** Stabilization effect is automatic, default. */ + EStabilizationAuto = 0x01, + /** Stabilization effect is very small in magnitude. */ + EStabilizationFine = 0x02, + /** Stabilization effect is average in magnitude. */ + EStabilizationMedium = 0x04, + /** Stabilization effect is large in magnitude. */ + EStabilizationStrong = 0x08 + }; + + /** Supported stabilization algorithms, graded on complexity. */ + enum TStabilizationAlgorithmComplexity + { + /** Stabilization algorithm selection is automatic, default. */ + EStabilizationComplexityAuto = 0x00, + /** Stabilization algorithm is simple - less precise but fast. */ + EStabilizationComplexityLow = 0x01, + /** Stabilization algorithm is of medium complexity. */ + EStabilizationComplexityMedium = 0x02, + /** Stabilization algorithm is of high complexity. */ + EStabilizationComplexityHigh = 0x04 + }; + + /** Supported focus modes. */ + enum TFocusMode + { + /** Focus mode is unknown. */ + EFocusModeUnknown = 0x00, + /** Focus is automatic, default. */ + EFocusModeAuto = 0x01, + /** Focus is fixed. */ + EFocusModeFixed = 0x02, + /** Focus is manually set. */ + EFocusModeManual = 0x04 + }; + + /** Supported focus ranges. */ + enum TFocusRange + { + /** Auto. Default */ + EFocusRangeAuto = 0x00, + /** Focus operates in close range (macro). */ + EFocusRangeMacro = 0x01, + /** Normal operation. */ + EFocusRangeNormal = 0x02, + /** Extended (tele) operation. */ + EFocusRangeTele = 0x04, + /** Focus at larger areas at short to medium distance. */ + EFocusRangePortrait = 0x08, + /** Optimised macro operation, + where depth of field is very shallow and observation area changes quickly. */ + EFocusRangeSuperMacro = 0x10, + /** + All objects at distances from half of the hyperfocal distance out to infinity will be in focus. + This gives gives maximum depth of field. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EFocusRangeHyperfocal = 0x20, + /** + When there is a near obstacle or better focus wanted for far away objects. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EFocusRangeInfinite = 0x40 + }; + + /** Specifies the supported autofocus types. */ + enum TAutoFocusType + { + /** Autofocus is switched off. */ + EAutoFocusTypeOff = 0x00, + /** Operates on a single shot, consumes less power. */ + EAutoFocusTypeSingle = 0x01, + /** Continious autofocus, more precise but consumes more power. + also known as AF Servo. */ + EAutoFocusTypeContinuous = 0x02 + }; + + /** Specifies the autofocus area. */ + enum TAutoFocusArea + { + /** Automatic. Default value */ + EAutoFocusTypeAuto = 0x00, + /** Single area, suitable for relatively flat surfaces and portrait. */ + EAutoFocusTypeSingleArea = 0x01, + /** Multiple points of an object, more weighting for centre points. */ + EAutoFocusTypeMultiAreaCentered = 0x02 + }; + + /** Specifies the Metering mode for the camera. + EMeteringModeAuto is the default value. */ + enum TMeteringMode + { + /** Automatic mode, default. */ + EMeteringModeAuto = 0x0000, + /** Metering in which the center is given a weighted priority. */ + EMeteringModeCenterWeighted = 0x0001, + /** Metering of a central area/spot only, also known as partial. */ + EMeteringModeSpot = 0x0002, + /** Metering is evaluated over a matrix(several spots) and calculated + as a function of that. Usually best but with increased + power consumption. Alternative name multi-metering mode. */ + EMeteringModeEvaluative = 0x0004 + }; + + /** Specifies the drive mode for the camera. This determines how and in what sucession are images + shot. EDriveModeSingleShot is the default.*/ + enum TDriveMode + { + /** Automatic. Default */ + EDriveModeAuto = 0x0000, + /** Camera takes a single image/shot. */ + EDriveModeSingleShot = 0x0001, + /** Camera continuously captures images (as fast as it can) until stopped or out of storage medium. */ + EDriveModeContinuous = 0x0002, + /** Camera is in bracketing mode, producing individual frames. @see TBracketMode */ + EDriveModeBracket = 0x0004, + /** Camera is in bracketing mode, but producing a single image. @see TBracketMode */ + EDriveModeBracketMerge = 0x0008, + /** camera captures a single shot after specified time period. @see Timer() */ + EDriveModeTimed = 0x0010, + /** Camera captures a set of images with an uniform interval between them. @see TimeLapse() */ + EDriveModeTimeLapse = 0x0020, + /** Camera captures a set of images as fast as it can, but in batches(bursts). */ + EDriveModeBurst = 0x0040 + }; + + /** Specifies Bracket mode. */ + enum TBracketMode + { + /** Bracket mode is switched off. Default value. */ + EBracketModeOff = 0x0000, + /** Bracket mode on. Three consecutive pictures are taken in order + under (-1), on (0), over (+1), where correction magnitude + is defined by bracket step size and by TBracketParameter + @see TBracketStep + @see TBracketParameter */ + EBracketMode3Image = 0x0001, + /** Bracket mode on. Five consecutive pictures are taken in order + under (-2),under (-1), on (0), over (+1), over (+2), where correction magnitude + is defined by bracket step size and by TBracketParameter + @see TBracketStep + @see TBracketParameter */ + EBracketMode5Image = 0x0002 + }; + + /** Supported parameters used for bracketing. + @note Bracket mode parameter value changes by + a selected uniform step between successive image shots. + @see TBracketStep + @see TBracketMode. */ + enum TBracketParameter + { + /** None. */ + EBracketParameterNone = 0x0000, + /** Exposure settings change. */ + EBracketParameterExposure = 0x0001, + /** Flash power change. */ + EBracketParameterFlashPower = 0x0002, + /** Colour balance settings change. */ + EBracketParameterColourBalance = 0x0004, + /** Aperture settings change. */ + BracketParameterAperture = 0x0008, + /** Autofocus settings change. */ + BracketParameterAutoFocus = 0x0010 + }; + + /** Specifies the magnitude of bracketing step. + The actual value and availability is parameter dependent. + @see TBracketParameter + */ + enum TBracketStep + { + /** Not supported. */ + EBracketStepNonConfig = 0x00, + /** Small value. */ + EBracketStepSmall = 0x01, + /** Medium value. */ + EBracketStepMedium = 0x02, + /** Large value. */ + EBracketStepLarge = 0x04 + }; + + /** Specifies the orientation of the picture. */ + enum TPictureOrientation + { + /** No information about picture orientation. */ + EPictureOrientationUnknown = 0x00, + /** Portrait - height larger than width. */ + EPictureOrientationPortrait = 0x01, + /** Landscape width larger than height. */ + EPictureOrientationLandscape = 0x02, + /** Square width equals the height. */ + EPictureOrientationSquare = 0x04 + }; + + /** Specifies the pixel aspect ratio + @note It is specified as a fraction of + (x) horizontal pixel size divided by vertical (y) pixel size. + The pixel aspect ratio for square pixels is 1/1. + */ + enum TPixelAspectRatio + { + /** Pixel ratio undetermined */ + EPixelAspectUnknown = 0x00, + /** Pixel Ratio 1:1. */ + EPixelAspect1To1 = 0x01, + /** Pixel Ratio 12:11 */ + EPixelAspect12To11 = 0x02, + /** Pixel Ratio 11:10. */ + EEPixelAspect11To10 = 0x04, + /** Pixel Ratio 59:54. */ + EEPixelAspect59To54 = 0x08, + /** Pixel Ratio 16:11. + @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() + */ + EEPixelAspect16To11 = 0x10, + /** Pixel Ratio 10:11. + @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() + */ + EEPixelAspect10To11 = 0x20, + /** Pixel Ratio 40:33. + @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() + */ + EEPixelAspect40To33 = 0x40 + }; + + /** Specifies YUV colour space dynamic range. + @note video compressors often use narrower than the default range. + The nominal Y range is [16:235] and the U and V ranges [16:240]. + */ + enum TYuvRange + { + /** Yuv range undetermined */ + EYuvRangeUnknown = 0x00, + /** Yuv Full Range. The nominal Y,U and V colours range is [0:255]. */ + EYuvRangeFull = 0x01, + /** Yuv Cropped Range. The nominal Y range is [16:235] and the U and V ranges [16:240]. */ + EYuvRangeVideoCropped = 0x02 + }; + + /** Specifies the units supported by the camera for manual white balance setting. + */ + enum TWBUnits + { + /** The units type is undetermined or not supported. */ + EWBUnknown, + /** The white balance is represented as temperature degrees in Kelvin. */ + EWBColorTemperature, + /** The white balance is represented as RGB triples. */ + EWBRgb + }; + + /** + Specifies the ISO type supported by the camera. ISO refers to the sensivity of the + image sensor and is one of the factors influencing the exposure. + + */ + enum TISORateType + { + /** ISO Not supported. Camera uses a fixed ISO rate internally and never reveals this information. */ + EISONone = 0x00, + /** 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. */ + EISOManual = 0x01, + /** Camera chooses the ISO on its own without prioritising any particular exposure parameters. */ + EISOAutoUnPrioritised = 0x02, + /** Camera chooses the ISO on its own by prioritising ISO. */ + EISOAutoISOPrioritised = 0x04, + /** Camera chooses the ISO on its own after prioritising shutter speed. */ + EISOAutoShutterSpeedPrioritised = 0x08, + /** Camera chooses the ISO on its own after prioritising aperture opening. */ + EISOAutoAperturePrioritised = 0x10 + }; + + /** + Specifies the unfavourable circumstances as pre capture warnings which may be issued before image/video capture. + + */ + enum TPreCaptureWarning + { + /** No warnings */ + EPCWNone = 0x0000, + /** warning to indicate that camera sensor is over exposed */ + EPCWOverExposure = 0x0001, + /** warning to indicate that camera sensor is under exposed */ + EPCWUnderExposure = 0x0002, + /** warning to indicate that camera operates under insufficient lightning conditions */ + EPCWLowLight = 0x0004, + /** warning to indicate that focussing is not optimum. This is valid for manual/fixed focus only */ + EPCWBadFocus = 0x0008, + /** warning to indicate that camera might not be firmly gripped (Tripod required). This is same as long exposure */ + EPCWHandShakePossible = 0x0010, + /** warning to indicate that camera has not enough power to survive the flash operations (battery discharged) */ + EPCWNotEnoughPowerForFlash = 0x0020, + /** warning to indicate that the current white balance is not the desired one */ + EPCWWrongWhiteBalanceValue = 0x0040, + /** warning to indicate that the current flash value is not the desired one */ + EPCWWrongFlashValue = 0x0080, + /** warning to indicate that the current digital zoom value is not the desired one */ + EPCWWrongDigiZoomValue = 0x0100, + /** warning to indicate that the desired digital zoom affects the quality of image */ + EPCWDigiZoomBadQuality = 0x0200, + /** warning to indicate that flash is not ready. Recommendation: user may subscribe for this warning or issue + IsFlashReady() also. Using both options is not encouraged */ + EPCWFlashNotReady = 0x0400, + /** unknown reason */ + EPCWGeneralWarning = 0x0800, + /** warning to indicate that flash has been overheated. + + @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() + + @publishedPartner + @prototype + */ + EPCWFlashOverheated = 0x1000, + /** warning to indicate that flash will not be fired because of enough ambient light. + + @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() + + @publishedPartner + @prototype + */ + EPCWFlashNotNeeded = 0x2000 + }; + + /** + Describes the camera mode. + + */ + enum TCameraMode + { + /** Camera is Idle */ + EModeIdle = 0x00, + /** DSA based Viewfinder runs */ + EModeDSAViewFinder = 0x01, + /** Client based Viewfinder runs */ + EModeClientViewFinder = 0x02 + }; + + /** + Specifies the different types of auto focus assistant light + */ + enum TAFAssistantLight + { + /** switch off the AF assistant light from either of 'manual on' or 'auto' mode */ + EAFAssistantLightOff = 0x00, + /** switch on the AF assistant light manually */ + EAFAssistantLightManualOn = 0x01, + /** Put the AF assistant light in auto mode. It will be automatically decided when to switch on or off. */ + EAFAssistantLightAuto = 0x02 + }; + + /** + Specifies the different types of continuous zoom supported. + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TContinuousZoomType + { + /** Continuous zoom not supported */ + EContinuousZoomNotSupported = 0x00, + /** Continuous zoom 'Optical' only, No 'Digital' */ + EContinuousZoomOpticalOnly = 0x01, + /** Continuous zoom 'Optical' and 'Digital' */ + EContinuousZoomMixed = 0x02, + /** Continuous zoom 'Digital' only, No 'Optical' */ + EContinuousZoomDigitalOnly = 0x04 + }; + + /** + Specifies the zoom direction for continuous zoom operation. + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TZoomDirection + { + /** Implies that feature not supported. */ + EZoomDirectionNone =0x00, + /** Implies zooming out. */ + EZoomDirectionWide =0x01, + /** Implies zooming in. */ + EZoomDirectionTele =0x02 + }; + + /** + Different levels for performance vectors like speed, quality, low memory consumption and low power consumption. + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TPerformanceLevel + { + /** High level preference. */ + ELevelHigh = 1, + /** Medium level preference. */ + ELevelMedium = 2, + /** Low level preference. */ + ELevelLow = 3, + /** Dont care (No preference). */ + ELevelDontCare = 4 + }; + + /** + Specifies flicker removal options. + The enumeration list may be extended in future. + + @internalTechnology + */ + enum TFlickerRemoval + { + /** Not Supported. */ + EFlickerRemovalNone = 0x00, + /** Flicker removal for Field frequency of 50Hz. */ + EFlickerRemoval50Hz = 0x01, + /** Flicker removal for Field frequency of 60Hz. */ + EFlickerRemoval60Hz = 0x02, + /** Auto flicker removal. */ + EFlickerRemovalAuto = 0x04, + /** Switch Off flicker removal. */ + EFlickerRemovalSwitchOff = 0x08 + }; + + /** + Specifes the type of neutral density filters available. + The enumeration list may be extended in future. + + @internalTechnology + */ + enum TNDFilter + { + /** Not Supported. */ + ENDFilterNone = 0x00, + /** Auto ND Filter. */ + ENDFilterAuto = 0x01, + /** Switched off ND Filter. */ + ENDFilterSwitchedOff = 0x02, + /** High level ND Filter. */ + ENDFilterHigh = 0x04, + /** Medium level ND Filter. */ + ENDFilterMedium = 0x08, + /** Low level ND Filter. */ + ENDFilterLow = 0x10, + /** General ND Filter. */ + ENDFilterGeneral = 0x20 + }; + + /** + Specifies the various events for which the LED effects could be used. + The enumeration list may be extended in future. + + @internalTechnology + */ + enum TLEDEvent + { + /** Not supported. */ + ELEDEventNone = 0x00, + /** LED effect needed for self timer. */ + ELEDEventSelfTimer = 0x01, + /** LED effect needed for starting of viewfinder. */ + ELEDEventViewfinderStart = 0x02, + /** LED effect needed for stoping of viewfinder. */ + ELEDEventViewfinderStop = 0x04, + /** LED effect needed for still image capture. */ + ELEDEventStillImageCapture = 0x08, + /** LED effect needed for video recording. */ + ELEDEventVideoRecording = 0x10 + }; + + /** + Specifes the type of LED effects available. + The enumeration list may be extended in future. + + @internalTechnology + */ + enum TLEDEffect + { + /** Not supported. */ + ELEDEffectNone =0x00, + /** LED always on. */ + ELEDEffectHardwired =0x01, + /** LED auto. */ + ELEDEffectAuto =0x02, + /** LED Effect manually switched on. */ + ELEDEffectManualSwitchOn =0x04, + /** LED Effect switched off. */ + ELEDEffectSwitchOff =0x08, + /** LED Custom Effect. */ + ELEDEffectCustom =0x10 + }; + + /** + Color channels on which manual gain can be selectively applied. + The enumeration list may be extended in future. + + @internalTechnology + */ + enum TColorChannel + { + /** Red Color Channel (RGB model). */ + EColorChannelRed, + /** Green Color Channel (RGB model). */ + EColorChannelGreen, + /** Blue Color Channel (RGB model). */ + EColorChannelBlue, + /** Luminance Y component (YUV model). */ + EChannelLumaY, + /** Chrominance U component (YUV model). */ + EChannelChromaU, + /** Chrominance V component (YUV model). */ + EChannelChromaV + }; + + /** + Class used to provide a particular custom LED effect. + + @internalTechnology + */ + class TECamLEDSpecialEffectStep + { + public: + TECamLEDSpecialEffectStep(); + + TUint Size() const; + TUint Version() const; + + private: + //for future expansion + TUint iSize:24; + TUint iVersion:8; + + // reserved for future expansion. + TInt iReserved1; + TInt iReserved2; + TInt iReserved3; + + public: + /** Blinking frequency of LED in Hertz. */ + TUint iBlinkingFrequency; + /** Represents the intensity of LED in millicandela. */ + TUint iIntensity; + /** Frequency step with which the blinking frequency changes with time. May be positive as well as negative. */ + TInt iFrequencyStep; + /** Time duration for which the particular LED special effect step would be valid. */ + TTimeIntervalMicroSeconds32 iDuration; + }; + + +public: + + IMPORT_C static CCameraAdvancedSettings* NewL(CCamera& aCamera); + + IMPORT_C TCameraType CameraType() const; + + IMPORT_C TCameraType CameraType(TInt aCameraIndex); + + IMPORT_C TBool IsCameraPresent() const; + + IMPORT_C TBool IsCameraPresent(TInt aCameraIndex); + + IMPORT_C TInt CameraIndex() const; + + IMPORT_C TInt SupportedStabilizationModes() const; + + IMPORT_C TStabilizationMode StabilizationMode() const; + + IMPORT_C void SetStabilizationMode(TStabilizationMode aStabilizationMode); + + IMPORT_C TInt SupportedFocusModes() const; + + IMPORT_C TFocusMode FocusMode() const; + + IMPORT_C void SetFocusMode(TFocusMode aFocusMode); + + IMPORT_C TInt SupportedFocusRanges() const; + + IMPORT_C TFocusRange FocusRange() const; + + IMPORT_C void SetFocusRange(TFocusRange aFocusRange); + + IMPORT_C TInt SupportedAutoFocusTypes() const; + + IMPORT_C TAutoFocusType AutoFocusType() const; + + IMPORT_C void SetAutoFocusType(TAutoFocusType aAutoFocusType); + + IMPORT_C TInt SupportedAutoFocusAreas() const; + + IMPORT_C TAutoFocusArea AutoFocusArea() const; + + IMPORT_C void SetAutoFocusArea(TAutoFocusArea aAutoFocusArea); + + IMPORT_C TInt FocusDistance() const; + + IMPORT_C void SetFocusDistance(TInt aDistance); + + IMPORT_C TInt GetMinFocalLength() const; + + IMPORT_C void GetSupportedIsoRatesL(RArray& aSupportedIsoRates) const; + + IMPORT_C TInt IsoRate() const; + + IMPORT_C void SetIsoRate(TInt aRate); + + IMPORT_C void GetAperturesL(RArray& aFStops, TValueInfo& aInfo) const; + + IMPORT_C TInt Aperture() const; + + IMPORT_C void SetAperture(TInt aFStop); + + IMPORT_C void GetShutterSpeedsL(RArray& aShutterSpeeds, TValueInfo& aInfo) const; + + IMPORT_C TInt ShutterSpeed() const; + + IMPORT_C void SetShutterSpeed(TInt aShutterSpeed); + + IMPORT_C TInt SupportedMeteringModes() const; + + IMPORT_C TMeteringMode MeteringMode() const; + + IMPORT_C void SetMeteringMode(TMeteringMode aMeteringMode); + + IMPORT_C TInt SupportedDriveModes() const; + + IMPORT_C TDriveMode DriveMode() const; + + IMPORT_C void SetDriveMode(TDriveMode aDriveMode); + + IMPORT_C TInt SupportedBracketModes() const; + + IMPORT_C TBracketMode BracketMode() const; + + IMPORT_C void SetBracketMode(TBracketMode aBracketMode); + + IMPORT_C TInt SupportedBracketParameters() const; + + IMPORT_C TBracketParameter BracketParameter() const; + + IMPORT_C void SetBracketParameter(TBracketParameter aBracketParameter); + + IMPORT_C TInt SupportedBracketSteps() const; + + IMPORT_C TBracketStep BracketStep() const; + + IMPORT_C void SetBracketStep(TBracketStep aBracketStep); + + IMPORT_C void GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const; + + IMPORT_C void SetBracketMerge(TInt aStartIndex, TInt aFrames); + + IMPORT_C TInt SupportedFlashModes() const; + + IMPORT_C CCamera::TFlash FlashMode() const; + + IMPORT_C void SetFlashMode(CCamera::TFlash aMode); + + IMPORT_C TBool RedEyeReduceOn() const; + + IMPORT_C void SetRedEyeReduceOn(TBool aState); + + IMPORT_C void GetFlashCompensationStepsL(RArray& aFlashCompensationSteps, TValueInfo& aInfo) const; + + IMPORT_C TInt FlashCompensationStep() const; + + IMPORT_C TInt GetFlashCompensationStep(TInt& aFlashCompensationStep) const; + + IMPORT_C void SetFlashCompensationStep(TInt aFlashCompensationStep); + + IMPORT_C void GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const; + + IMPORT_C TInt FlashCompensation() const; + + IMPORT_C TInt GetFlashCompensation(TInt& aFlashCompensation) const; + + IMPORT_C void SetFlashCompensation(TInt aFlashCompensationInSteps); + + IMPORT_C TBool IsExternalFlashPresent() const; + + IMPORT_C void GetManualFlashPowerLevelsL(RArray& aManualFlashPowerLevels, TValueInfo& aInfo) const; + + IMPORT_C TInt ManualFlashPowerLevel() const; + + IMPORT_C void SetManualFlashPowerLevel(TInt aManualFlashPowerLevel); + + IMPORT_C TInt SupportedExposureModes() const; + + IMPORT_C CCamera::TExposure ExposureMode() const; + + IMPORT_C void SetExposureMode(CCamera::TExposure aExposureMode); + + IMPORT_C void GetExposureCompensationStepsL(RArray& aExposureCompensationSteps, TValueInfo& aInfo) const; + + IMPORT_C TInt ExposureCompensationStep() const; + + IMPORT_C TInt GetExposureCompensationStep(TInt& aExposureCompensationStep) const; + + IMPORT_C void SetExposureCompensationStep(TInt aExposureCompensationStep); + + IMPORT_C void GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const; + + IMPORT_C TInt ExposureCompensation() const; + + IMPORT_C TInt GetExposureCompensation(TInt& aExposureCompensation) const; + + IMPORT_C void SetExposureCompensation(TInt aExposureCompensationInSteps); + + IMPORT_C TInt SupportedWhiteBalanceModes() const; + + IMPORT_C CCamera::TWhiteBalance WhiteBalanceMode() const; + + IMPORT_C void SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode); + + IMPORT_C TBool ApertureExposureLockOn() const; + + IMPORT_C void SetApertureExposureLockOn(TBool aAELock); + + IMPORT_C TBool ShootClickOn() const; + + IMPORT_C void SetShootClickOn(TBool aShootClickOn); + + IMPORT_C void GetTimerIntervalsL(RArray& aTimerIntervals, TValueInfo& aInfo) const; + + IMPORT_C TInt TimerInterval() const; + + IMPORT_C void SetTimerInterval(TInt aTimerInterval); + + IMPORT_C void GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const; + + IMPORT_C void GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const; + + IMPORT_C void SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval); + + IMPORT_C TPictureOrientation PictureOrientation() const; + + IMPORT_C void SetPictureOrientation(TPictureOrientation aOrientation); + + IMPORT_C TInt SupportedPixelAspectRatios() const; + + IMPORT_C TPixelAspectRatio PixelAspectRatio() const; + + IMPORT_C void SetPixelAspectRatio(TPixelAspectRatio aPixelAspectRatio); + + IMPORT_C TInt SupportedYuvRanges() const; + + IMPORT_C TYuvRange YuvRange() const; + + IMPORT_C void SetYuvRange(TYuvRange aYuvRange); + + IMPORT_C TInt BurstImages() const; + + IMPORT_C void SetBurstImages(TInt aImages); + + IMPORT_C void GetOpticalZoomStepsL(RArray& aOpticalZoomSteps, TValueInfo& aInfo) const; + + IMPORT_C TInt OpticalZoom() const; + + IMPORT_C void SetOpticalZoom(TInt aOpticalZoom); + + IMPORT_C void GetDigitalZoomStepsL(RArray& aDigitalZoomSteps, TValueInfo& aInfo) const; + + IMPORT_C TInt DigitalZoom() const; + + IMPORT_C void SetDigitalZoom(TInt aDigitalZoom); + + IMPORT_C TBool ExposureLockOn() const; + + IMPORT_C void SetExposureLockOn(TBool aState); + + IMPORT_C TBool AutoFocusLockOn() const; + + IMPORT_C void SetAutoFocusLockOn(TBool aState); + + IMPORT_C void GetSupportedSettingsL(RArray& aSettings) const; + + IMPORT_C void GetActiveSettingsL(RArray& aActiveSettings) const; + + IMPORT_C void GetDisabledSettingsL(RArray& aDisabledSettings) const; + + IMPORT_C TBool AutomaticSizeSelectionChangeOn() const; + + IMPORT_C void SetAutomaticSizeSelectionChangeOn(TBool aSetOn); + + IMPORT_C void GetSupportedContinuousAutoFocusTimeoutsL(RArray& aTimeouts, TValueInfo& aInfo) const; + + IMPORT_C TInt ContinuousAutoFocusTimeout() const; + + IMPORT_C void SetContinuousAutoFocusTimeout(TInt aTimeout); + + IMPORT_C TInt SupportedStabilizationEffects() const; + + IMPORT_C TStabilizationEffect StabilizationEffect() const; + + IMPORT_C void SetStabilizationEffect(TStabilizationEffect aEffect); + + IMPORT_C TInt SupportedStabilizationComplexityValues() const; + + IMPORT_C TStabilizationAlgorithmComplexity StabilizationComplexity() const; + + IMPORT_C void SetStabilizationComplexity(TStabilizationAlgorithmComplexity aComplexity); + + IMPORT_C TWBUnits SupportedWBUnits() const; + + IMPORT_C void GetWBRgbValue(TRgb& aValue) const; + + IMPORT_C void SetWBRgbValue(const TRgb& aValue); + + IMPORT_C void GetWBSupportedColorTemperaturesL(RArray& aWBColorTemperatures, TValueInfo& aInfo) const; + + IMPORT_C TInt WBColorTemperature() const; + + IMPORT_C void SetWBColorTemperature(TInt aWBColorTemperature); + + IMPORT_C ~CCameraAdvancedSettings(); + + IMPORT_C TInt IsFlashReady(TBool& aReady) const; + + IMPORT_C void GetCurrentFocusModeStepsL(RArray& aFocusModeSteps, TValueInfo& aInfo) const; + + IMPORT_C void GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const; + + IMPORT_C void SetISORateL(TISORateType aISORateType, TInt aParam); + + IMPORT_C void GetISORateL(TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const; + + IMPORT_C void SetReferenceScreenL(CWsScreenDevice& aScreenDevice); + + IMPORT_C void GetDigitalZoomStepsForStillL(RArray& aDigitalZoomSteps, TValueInfo& aInfo, TInt aSizeIndex, + CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const; + + IMPORT_C void GetDigitalZoomStepsForVideoL(RArray& aDigitalZoomSteps, TValueInfo& aInfo, TInt aFrameRateIndex, + TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible, CCamera::TExposure aExposure) const; + + IMPORT_C void GetPreCaptureWarningSupportedL(TCameraMode aCameraMode, TInt& aPreCaptureWarningSupported) const; + + IMPORT_C void SubscribeToPreCaptureWarningL(TInt aPreCaptureWarning); + + IMPORT_C void UnSubscribePreCaptureWarningL(); + + IMPORT_C void GetPreCaptureWarningL(TInt& aPreCaptureWarning) const; + + IMPORT_C void GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const; + + IMPORT_C void GetAFAssistantLightL(TAFAssistantLight& aAFAssistantLight) const; + + IMPORT_C void SetAFAssistantLightL(TAFAssistantLight aAFAssistantLight); + + IMPORT_C void GetSupportedContinuousZoomTypeL(TUint& aSupportedContinuousZoomType) const; + + IMPORT_C void StartContinuousZoomL(TContinuousZoomType aContinuousZoomType, TZoomDirection aZoomDirection); + + IMPORT_C void StopContinuousZoom(); + + IMPORT_C void GetFocalLengthInfoL(TInt& aMinFocalLength, TInt& aCurrentFocalLength, TInt& aMaxFocalLength) const; + + IMPORT_C void GetNumOperationPreferenceL(TUint& aNumOperationPreferenceSupported) const; + + IMPORT_C void EnumerateOperationPreferenceL(TUint aOperationPreferenceIndex, TPerformanceLevel& aSpeedLevel, + TPerformanceLevel& aQualityLevel, TPerformanceLevel& aLowMemoryConsumptionLevel, + TPerformanceLevel& aLowPowerConsumptionLevel) const; + + IMPORT_C void SetOperationPreferenceL(TUint aOperationPreferenceIndex); + + IMPORT_C void GetOperationPreferenceL(TInt& aOperationPreferenceIndex) const; + + IMPORT_C void GetSupportedEventsL(RArray& aSupportedEvents) const; + + IMPORT_C void GetIndirectFeatureChangesL(TUid aRequestedSetting, RArray& aIndirectFeatureChanges) const; + +private: + IMPORT_C CCameraAdvancedSettings(CCamera& aOwner); + IMPORT_C void ConstructL(); + +private: + void RegisterEventsL(TECAMEventFilterScheme aEventFilter, const RArray& aEvents); + void GetRegisterEventsL(TECAMEventFilterScheme aEventFilter, RArray& aEvents, TValueInfo& aInfo) const; + + void GetSupportedFlickerRemovalValueL(TUint& aSupportedFlickerRemovalValue) const; + void GetFlickerRemovalValueL(TFlickerRemoval& aFlickerRemovalValue) const; + void SetFlickerRemovalValueL(TFlickerRemoval aFlickerRemovalValue); + + void GetSupportedNDFilterL(TUint& aSupportedNDFilter) const; + void GetNDFilterL(TNDFilter& aNDFilter) const; + void SetNDFilterL(TNDFilter aNDFilter); + + void GetLEDEffectL(TLEDEvent aLEDEvent, TLEDEffect& aLEDEffect) const; + void SetLEDEffectL(TLEDEvent aLEDEvent, TLEDEffect aLEDEffect); + void SetLEDCustomEffectL(TLEDEvent aLEDEvent, const RArray& aLEDSpecialEffectSteps); + + void ReserveL(const TTimeIntervalMicroSeconds32& aMaxTimeToWait, TBool aKickOut); + void SetClientPriorityL(TInt aPriority); + void RestoreClientPriorityL(); + + void GetSupportedManualGainL(RArray& aSupportedManualGain, TColorChannel aColorChannel) const; + void GetManualGainL(TInt& aManualGain, TColorChannel aColorChannel) const; + void SetManualGainL(TInt aManualGain, TColorChannel aColorChannel); + + void SetWhiteBalanceLockL(TBool aEnableLock); + void GetWhiteBalanceLockStateL(TBool& aIsLocked) const; + + void EnableStateSavingL(RWriteStream& aLatestCameraState); + void DisableStateSavingL(); + void RestoreLatestStateL(RReadStream& aLatestCameraState); + void SaveCameraStateL(RWriteStream& aCustomCameraState); + void DisableCameraStateSavingL(RWriteStream& aCustomCameraState); + void RestoreCameraStateL(RReadStream& aCustomCameraState); + +private: + CCamera& iOwner; + MCameraAdvancedSettings* iImpl; // not owned + MCameraAdvancedSettings2* iImpl2; // not owned + + MCameraAdvancedSettings3* iImpl3; // not owned + + MCameraAdvancedSettings4* iImpl4; // not owned + }; + +/** +Supported presets with the assumption for scope and outcome +*/ + +/** Default settings */ +static const TUid KUidECamPresetFactoryDefault = {KUidECamPresetFactoryDefaultUidValue}; +/** Daytime shot with normal exposure time, one shot autofocus, +medium ISO rating and no flash. */ +static const TUid KUidECamPresetOutdoor = {KUidECamPresetOutdoorUidValue}; +/** Daytime shot with short exposure time, continuous autofocus, +high Iso rating and no flash. */ +static const TUid KUidECamPresetOutdoorSport = {KUidECamPresetOutdoorSportUidValue}; +/** Daytime shot with very short exposure time, high shutter speed, +high Iso rating and no flash. */ +static const TUid KUidECamPresetSnow = {KUidECamPresetSnowUidValue}; +/** Daytime shot with very short exposure time, high shutter speed, +high contrast, reflections and no flash. */ +static const TUid KUidECamPresetBeach = {KUidECamPresetBeachUidValue}; +/** Night time shot with long central exposure time and high flash power. */ +static const TUid KUidECamPresetNightPortrait = {KUidECamPresetNightPortraitUidValue}; +/** Night time shot with long exposure time and no flash. */ +static const TUid KUidECamPresetNightFireworks = {KUidECamPresetNightFireworksUidValue}; +/** Daytime shot with medium exposure time, medium to high Iso rating, +overcast daylight, low contrast, fill-in flash. */ +static const TUid KUidECamPresetFog = {KUidECamPresetFogUidValue}; +/** Fluorescent lightning with medium exposure time, +medium to low shutter speed with flash. */ +static const TUid KUidECamPresetIndoor = {KUidECamPresetIndoorUidValue}; +/** Fluorescent lightning with continuous autofocus, wide aperture, +high Iso rating with flash. */ +static const TUid KUidECamPresetIndoorSport = {KUidECamPresetIndoorSportUidValue}; +/** +Used in low light situations. Tries to capture all the photons from a low light scene. +The image may be processed longer to achieve this. This case may cause blurring, but that could be a +wanted effect. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetNightPartyIndoor = {KUidECamPresetNightPartyIndoorUidValue}; +/** +Used to capture images of things which can't be seen by eye. +For example: snowflakes, underwater photography, small insect photos + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetNightCloseUp = {KUidECamPresetNightCloseUpUidValue}; +/** +Used for revealing assumed details. For example: business card photos, small written text photos, +underwater photography, insect photos. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetNightMacro = {KUidECamPresetNightMacroUidValue}; +/** +Used for taking clear pictures of text or drawings. Also used to capture business cards or of a whiteboard. +Aim is to optimise text and drawing readability and user expectation of "white" paper. +Camera shake may reduce quality in case no flash available or not adequate(distance too much from subject). + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetTextDocument = {KUidECamPresetTextDocumentUidValue}; +/** +Used for providing clear pictures of barcode. Aim is to convert barcode into some form which can be easily decoded. +Camera shake may reduce this barcode readability and hence, barcode conversion accuracy and reliability. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetBarcode = {KUidECamPresetBarcodeUidValue}; +/** +Used when factory default preset in certain cases may not be available or is too restrictive. +Automatic preset expects the hardware to use automatic detection for most of the features. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetAuto = {KUidECamPresetAutoUidValue}; +/** +Used for portraits of human subjects in good lighting conditions. Focuses on the people and captures natural +skin tones. Background details may not be softened. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetPortrait = {KUidECamPresetPortraitUidValue}; +/** +Used for sharp landscape shots with clear outlines, colours and contrast, for example forest, sky. +The main aim is to get the details of the scene. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetLandscape = {KUidECamPresetLandscapeUidValue}; +/** +Used to retain the ambience/mood produced by, for example, warm lighting conditions like sunset, candlelight etc. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +*/ +static const TUid KUidECamPresetAmbienceMood = {KUidECamPresetAmbienceMoodUidValue}; +/** +Used to for video telephony. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +@publishedPartner +@prototype +*/ +static const TUid KUidECamPresetVideoTelephony = {KUidECamPresetVideoTelephonyUidValue}; + +/** +Used to clarify that camera is not under any preset mode. Possible scenario: client sets camera in a particular preset +mode and then makes some setting changes on top of it. Then theoretically camera is out of that preset. Hence, +KUidECamPresetNone will be used in such cases. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +@publishedPartner +@prototype +*/ +static const TUid KUidECamPresetNone = {KUidECamPresetNoneUidValue}; + +/** Notifications related to presets */ +/** +Used to notify clients about possible range restrictions, when camera works under a particular preset mode. +This is not a particular preset uid. + +@note Call CCamera::CCameraPresets::GetRangeRestrictedSettingsL(RArray& aRangeRestrictedSettings) to retrieve + the list of settings whose range have been restricted. + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventRangeRestricted = {KUidECamEventRangeRestrictedUidValue}; + +/** +Used to notify clients about possible feature restrictions, when camera works under a particular preset mode. +This is not a particular preset uid. + +@note Call CCamera::CCameraPresets::GetFeatureRestrictedSettingsL(RArray& aFeatureRestrictedSettings) to retrieve + the list of settings which have been restricted. + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventFeatureRestricted = {KUidECamEventFeatureRestrictedUidValue}; + +/** +Used to notify clients that locking of the preset operation has completed, when camera works under a particular preset mode. +This is not a particular preset uid. + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventPresetLocked = {KUidECamEventPresetLockedUidValue}; + +/** +Used to notify clients that unlocking of the preset operation has completed, when camera works under a particular preset mode. +This is not a particular preset uid. + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventPresetUnlocked = {KUidECamEventPresetUnlockedUidValue}; + + +/** +This API is used to simplify user - camera interaction by allowing simultaneous +setting of various advanced camera hardware settings using a single parameter. + +Preset is identified by a single UID and relates to a known predefined outcome. +For example the 'Night' Preset will be used to set the camera into a night mode +so that the user can take night photos. + +The particular set of settings associated with the specific preset and their specific values +and ranges are camera hardware specific and outside the scope of this API. + +@note This class is not intended for sub-classing and used to standardise existing + varieties of implementations. + +@note If the class methods leave, the output type parameter value is not guaranteed to be valid. + +@publishedAll +@released +*/ +class CCamera::CCameraPresets : public CBase + { + /** allow access to private constructors. */ + friend class CCamera; + +public: + + IMPORT_C static CCameraPresets* NewL(CCamera& aCamera); + + IMPORT_C void GetSupportedPresetsL(RArray& aPresets) const; + + IMPORT_C void SetPreset(TUid aPreset); + + IMPORT_C TUid Preset() const; + + IMPORT_C void GetAffectedSettingsL(RArray& aSettings) const; + + IMPORT_C void GetAssociatedSettingsL(TUid aPreset, RArray& aSettings) const; + + IMPORT_C ~CCameraPresets(); + + IMPORT_C void GetRangeRestrictedSettingsL(RArray& aRangeRestrictedSettings) const; + + IMPORT_C void GetFeatureRestrictedSettingsL(RArray& aFeatureRestrictedSettings) const; + + IMPORT_C void IsPresetUnlockSupportedL(TBool& aUnlockSupported) const; + + IMPORT_C void LockPresetL(); + + IMPORT_C void UnlockPresetL(); + +private: + IMPORT_C CCameraPresets(CCamera& aOwner); + IMPORT_C void ConstructL(); + + void FilterUnrecognisedUids(RArray& aUids, const TInt aBaselineUid) const; + +private: + CCamera& iOwner; + MCameraPresets* iImpl; // not owned + MCameraPresets2* iImpl2; // not owned + }; + +#endif // ECAMADVSETTINGS_H