--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imagingandcamerafws/camerafw/Include/ECam/ecamadvsettingsintf.h Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,2138 @@
+// 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 "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+/**
+ @file
+ @publishedPartner
+ @released
+*/
+
+#ifndef ECAMADVSETTINGSINTF_H
+#define ECAMADVSETTINGSINTF_H
+
+#include <ecamadvsettings.h>
+#include <ecam/ecamimageprocessingintf.h>
+#include <ecam/ecamadvsettingsintfuids.hrh>
+
+/** This is the UID which is used to obtain the interface MCameraPresets, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+ */
+static const TUid KECamMCameraPresetsUid = {KECamMCameraPresetsUidValue};
+
+/**
+This is the UID which is used to obtain the interface MCameraPresets2, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+@publishedPartner
+@prototype
+*/
+static const TUid KECamMCameraPresets2Uid = {KECamMCameraPresets2UidValue};
+
+/** This is the UID which is used to obtain the interface MCameraAdvancedSettings, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface. */
+static const TUid KECamMCameraAdvancedSettingsUid = {KECamMCameraAdvancedSettingsUidValue};
+
+/** This is the UID which is used to obtain the interface MCameraAdvancedSettings2, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface. */
+static const TUid KECamMCameraAdvancedSettings2Uid = {KECamMCameraAdvancedSettings2UidValue};
+
+/**
+This is the UID which is used to obtain the interface MCameraAdvancedSettings3, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+*/
+static const TUid KECamMCameraAdvancedSettings3Uid = {KECamMCameraAdvancedSettings3UidValue};
+
+/**
+This is the UID which is used to obtain the interface MCameraAdvancedSettings4, via the
+CCamera::CustomInterface() call, which provides implementation of the M-class interface.
+@publishedPartner
+@prototype
+*/
+static const TUid KECamMCameraAdvancedSettings4Uid = {KECamMCameraAdvancedSettings4UidValue};
+
+/**
+This is the UID which is used to obtain the interface MCameraContinuousZoom, via the
+CCamera::CCameraAdvancedSettings::CreateContinuousZoomImpl() call, which provides
+implementation of the M-class interface.
+@internalTechnology
+@prototype
+*/
+static const TUid KECamMCameraContinuousZoomUid = {KECamMCameraContinuousZoomUidValue};
+
+/**
+Mixin class for implementation by providers of the Advanced Settings Camera Extension API.
+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.
+
+@publishedPartner
+@released
+*/
+class MCameraAdvancedSettings
+ {
+
+public:
+
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+
+ /**
+ Gets the type of this camera.
+ @see TCameraType
+
+ @return a TCameraType value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TCameraType CameraType() const=0;
+
+ /**
+ Get the type of a specific camera denoted by its index. A pluggable camera
+ may not necessarily be physically present. The type denotes whether the slot allocated
+ to that index is for pluggable or onboard camera.
+
+ @param aCameraIndex
+ An integer in the range of [0: CCamera::CamerasAvailable()-1].
+
+ @return the TCameraType value for the specific camera.
+ If the index is out of range, the return value is ECameraUnknown.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TCameraType CameraType(TInt aCameraIndex) const=0;
+
+ /**
+ Checks whether the current camera is present.
+
+ @return Whether the camera is currently present.
+ ETrue if camera is present, EFalse otherwise.
+ For example ECameraOnBoard (built-in) cameras are always present.
+ */
+ virtual TBool IsCameraPresent() const=0;
+
+ /**
+ Checks whether the camera, denoted by its index, is currently present.
+ The index uniquely identifies the camera on the device.
+
+ @param aCameraIndex
+ An integer in the range of [0:CCamera::CamerasAvailable()-1] specifying the
+ camera device to use
+
+ @return Whether the camera is currently present.
+ ETrue if camera is present, EFalse otherwise.
+ For example built-in (ECameraOnBoard) cameras
+ are always present.
+ */
+ virtual TBool IsCameraPresent(TInt aCameraIndex) const=0;
+
+ /**
+ Gets current camera index. The index uniquely identifies the camera on the device.
+
+ @return camera index in the inclusive range of [0:CCamera::CamerasAvailable() - 1].
+ */
+ virtual TInt CameraIndex() const=0;
+
+ /**
+ Gets all of the supported stabilization modes on the device. The result is a bitfield
+ of the valid TStabilizationMode flags.
+
+ @return a bitfield of all supported stabilization modes.
+ */
+ virtual TInt SupportedStabilizationModes() const=0;
+
+ /**
+ Gets current stabilization mode on the device.
+ The result is a valid TStabilizationMode value.
+
+ @return current stabilization mode of type TStabilizationMode.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TStabilizationMode StabilizationMode() const=0;
+
+ /**
+ Sets a specific stabilization mode on the device.
+
+ Stabilization mode change fires a KUidECamEventCameraSettingStabilizationMode
+ event to all MCameraObserver2 clients of this specific camera.
+
+ @param aStabilizationMode
+ new stabilization mode of TStabilizationMode type.
+ */
+ virtual void SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)=0;
+
+ /**
+ Gets all of the supported focus modes on the device. The result is a bitfield
+ of the valid TFocusMode flags.
+
+ @return a bitfield of all supported focus modes.
+ */
+ virtual TInt SupportedFocusModes() const=0;
+
+ /**
+ Gets current focus mode on the device.
+ The result is a valid TFocusMode value.
+
+ @return current focus mode.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TFocusMode FocusMode() const=0;
+
+ /**
+ Sets a specific focus mode on the device.
+ Focus mode change fires a KUidECamEventCameraSettingFocusMode event
+ to all MCameraObserver2 clients of the camera.
+
+ @param aFocusMode
+ new focus mode of TFocusMode type.
+ */
+ virtual void SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)=0;
+
+ /**
+ Gets all supported focus ranges on the device.
+
+ @return an integer - a bitfield of all supported TFocusRange values.
+ */
+ virtual TInt SupportedFocusRanges() const=0;
+
+ /**
+ Gets current focus range on the device.
+
+ @return the current TFocusRange value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TFocusRange FocusRange() const=0;
+
+ /**
+ Sets a specific focus range on the device.
+ The focus range change fires both, KUidECamEventCameraSettingFocusRange and
+ KUidECamEventCameraSettingFocusRange2 event to all MCameraObserver2 clients of the camera.
+ @see KUidECamEventCameraSettingFocusRange
+
+ @param aFocusRange
+ newly selected focus range.
+ */
+ virtual void SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)=0;
+
+ /**
+ Gets all supported auto focus types on the device.
+
+ @return an integer - a bitfield of all supported TAutoFocusType values.
+ */
+ virtual TInt SupportedAutoFocusTypes() const=0;
+
+ /**
+ Gets current auto focus type on the device.
+
+ @return a CCamera::TAutoFocusType value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TAutoFocusType AutoFocusType() const=0;
+
+ /**
+ Sets a specific auto focus type on the device.
+ The focus type change fires both, KUidECamEventCameraSettingAutoFocusType and
+ KUidECamEventCameraSettingAutoFocusType2 event to all MCameraObserver2 clients of the camera.
+ @see KUidECamEventCameraSettingAutoFocusType
+
+ @param aAutoFocusType
+ Autofocus selection.
+ */
+ virtual void SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)=0;
+
+ /**
+ Gets all supported auto focus areas on the device.
+
+ @return an integer - a bitfield of al supported TAutoFocusArea values.
+ */
+ virtual TInt SupportedAutoFocusAreas() const=0;
+
+ /**
+ Gets current chosen auto focus area on the device.
+
+ @return a CCamera::TAutoFocusArea value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TAutoFocusArea AutoFocusArea() const=0;
+
+ /**
+ Sets a specific auto focus area on the device.
+ Focus area change fires a KUidECamEventCameraSettingAutoFocusArea event
+ to all MCameraObserver2 clients of the camera.
+
+ @param aAutoFocusArea
+ Autofocus area selection.
+ */
+ virtual void SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)=0;
+
+ /**
+ Get focus distance in millimetres.
+
+ @return the current focus distance in millimetres, directly from user setting of lenses.
+ */
+ virtual TInt FocusDistance() const=0;
+
+ /**
+ Set focus distance in millimetres. Focus distance change fires a KUidECamEventCameraSettingFocusDistance event
+ to all MCameraObserver2 clients of the camera.
+
+ @param aDistance
+ the current value in millimetres, directly from user setting of lenses.
+ */
+ virtual void SetFocusDistance(TInt aDistance)=0;
+
+ /**
+ Get minimum focus distance in millimetres.
+
+ @return the minimum (35 camera equivalent) focal length of a device.
+ @note Current Focal length is calculated as
+ focalLength = opticalZoom * minFocalLength;
+ */
+ virtual TInt GetMinFocalLength() const=0;
+
+ /**
+ Gets the set of camera supported ISO rates.
+
+ @param aSupportedIsoRates
+ an array of integers which gets filled in with the supported ISO rates.
+
+ @note When camera device is incapable of revealing the ISO rates supported, it has to be assumed that
+ camera will work only on the parmanently set value. If this value is not known, empty array should be
+ returned, and the corresponding getter/setters for this feature for this feature should not be used.
+ */
+ virtual void GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const=0;
+
+ /**
+ Gets current ISO rate.
+
+ @return current ISO rate as a TInt value.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt IsoRate() const=0;
+
+ /**
+ Set current ISO rate for the camera.
+ Triggers a KUidECamEventCameraSettingIsoRate event to all MCameraObserver2 clients of the camera.
+
+ @param aRate
+ required new ISO rate.
+ */
+ virtual void SetIsoRate(TInt aRate)=0;
+
+ /**
+ Gets the current discrete aperture steps (F-stops) supported by the device.
+
+ @param aFStops
+ A reference to an empty array of TInt which would be populated by the implementation with
+ the specific supported values. If the array is empty on return,
+ the camera supports all integer values in the aperture range. Each value is multiplied by
+ a factor of KECamFineResolutionFactor.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @leave KErrNoMemory Out of memory.
+
+ @note When camera device is incapable of revealing the aperture openings supported, it has to be assumed that
+ camera will work only on the parmanently set value. If this value is not known, empty array should be
+ returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const=0;
+
+ /**
+ Get current aperture value.
+ The default aperture value is ECAM implementation specific and could be either auto aperture or any other supported value.
+
+ @return Current aperture value as an integer, multiplied by KECamFineResolutionFactor.
+ For example the function will return 280 for the actual aperture of F2.8.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt Aperture() const=0;
+
+ /**
+ Set a new aperture value.
+ All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingAperture
+ event notification when aperture value is changed.
+
+ @note The aperture parameter value is an integer, multiplied by KECamFineResolutionFactor.
+ For example to set an aperture of F2.8, call SetAperture(280).
+
+ @param aFStop
+ a new aperture value in the supported by the device range.
+ */
+ virtual void SetAperture(TInt aFStop)=0;
+
+ /**
+ Gets the set of supported shutter speeds
+
+ @param aShutterSpeeds
+ a reference to an RArray of TInt representing the discrete shutter speeds supported
+ currently by the device.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @return the populated array with all shutter speeds in microseconds.
+
+ @leave KErrNoMemory Out of memory.
+
+ @note When camera device is incapable of revealing the shutter speeds supported, it has to be assumed that
+ camera will work only on the parmanently set value. If this value is not known, empty array should be
+ returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const=0;
+
+ /**
+ Gets the current shutter speed
+
+ @return the current shutter speed in microseconds.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt ShutterSpeed() const=0;
+
+ /**
+ Sets the current shutter speed. When set, all MCameraObserver2 clients of the camera
+ receive a KUidECamEventCameraSettingShutterSpeed event
+
+ @param aShutterSpeed
+ the required shutter speed in microseconds.
+
+ */
+ virtual void SetShutterSpeed(TInt aShutterSpeed)=0;
+
+ /**
+ Get all supported metering modes on this device represented as bitfield of type TMeteringMode.
+
+ @return the set of supported metering modes.
+ */
+ virtual TInt SupportedMeteringModes() const=0;
+
+ /**
+ Get current metering mode.
+
+ @return a value of type TMeteringMode.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TMeteringMode MeteringMode() const=0;
+
+ /**
+ Set the current metering mode. When set, all MCameraObserver2 clients are notified
+ with a KUidECamEventCameraSettingMeteringMode event.
+
+ @param aMeteringMode
+ a new selection for metering mode of type TMeteringMode.
+ */
+ virtual void SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)=0;
+
+ /**
+ Get all supported drive modes as bitfields of TDriveMode type.
+
+ @return the set of supported drive modes.
+ */
+ virtual TInt SupportedDriveModes() const=0;
+
+ /**
+ Gets currently active drive mode.
+
+ @return current drive mode.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TDriveMode DriveMode() const=0;
+
+ /**
+ Set the current metering mode. When set all MCameraObserver2 clients are notified with a
+ KUidECamEventCameraSettingDriveMode event.
+
+ @param aDriveMode
+ new selection for drive mode value of type TDriveMode.
+
+ @note Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or PerformantStopVideoCaptureL())
+ if an image/video capture is still outstanding, this method may report error KErrInUse.
+ */
+ virtual void SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)=0;
+
+ /**
+ Get all supported bracket modes as bitfields.
+
+ @return the set of all supported bracket modes.
+ */
+ virtual TInt SupportedBracketModes() const=0;
+
+ /**
+ Get current bracket mode.
+
+ @return the current bracket mode TBracketMode.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TBracketMode BracketMode() const=0;
+
+ /**
+ Set new bracket mode. All MCameraObserver2 clients are notified with a
+ KUidECamEventCameraSettingBracketMode event.
+
+ @param aBracketMode
+ new selection for bracket mode of type TBracketMode.
+ */
+ virtual void SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)=0;
+
+ /**
+ Get all supported bracket parameters as bitfields.
+
+ @return the set of all currently supported bracket modes.
+ */
+ virtual TInt SupportedBracketParameters() const=0;
+
+ /**
+ Get current bracket parameter.
+
+ @return the current bracket mode TBracketParameter.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TBracketParameter BracketParameter() const=0;
+
+ /**
+ Set new bracket parameter
+ When set all clients are notified with a
+ KUidECamEventCameraSettingBracketParameter event.
+
+ @param aBracketParameter
+ new selection for parameter type of type TBracketParameter.
+ */
+ virtual void SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)=0;
+
+ /**
+ Get all supported bracket steps as bitfields.
+
+ @return the set of all supported bracket modes.
+ */
+ virtual TInt SupportedBracketSteps() const=0;
+
+ /**
+ Get current bracket step.
+
+ @return the current bracket mode TBracketStep.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TBracketStep BracketStep() const=0;
+
+ /**
+ Set new bracket step. All MCameraObserver2 clients are notified with
+ KUidECamEventCameraSettingBracketStep.
+
+ @param aBracketStep
+ new selection for step of type TBracketStep.
+ */
+ virtual void SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)=0;
+
+ /**
+ Gets the settings for which frames to merge. Valid only in EDriveModeBracketMerge mode.
+ @note there must be at least two images to merge. All are assumed to form a sequence and
+ are identified using the first frame index and number of frames e.g. to merge two frames - one
+ on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to two.
+ @note It is very much TBracketMode setting dependent.
+
+ @param aStartIndex
+ the index of the start frame, starts from 0.
+
+ @param aFrames
+ the number of frames to be merged.
+ */
+ virtual void GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const=0;
+
+ /**
+ Sets the settings for which frames to merge. Valid only in EDriveModeBracketMerge mode.
+ @note there must be at least two images to merge. All are assumed to form a sequence and
+ are identified using the first frame index and number of frames e.g. to merge two frames - one
+ on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to 2.
+ MCameraObserver2 clients are notified with a KUidECamEventBracketMerge event.
+
+ @note It is very TBracketMode setting dependent.
+
+ @param aStartIndex
+ the index of the start frame, starts from 0.
+
+ @param aFrames
+ the number of frames to be merged.
+ */
+ virtual void SetBracketMerge(TInt aStartIndex, TInt aFrames)=0;
+
+ /**
+ Get camera all supported flash modes CCamera::TFlash
+
+ @return the set of all supported flash modes as bitfields in an integer.
+ */
+ virtual TInt SupportedFlashModes() const=0;
+
+ /**
+ Gets the currently set flash mode.
+
+ @return The currently set flash mode.
+ */
+ virtual CCamera::TFlash FlashMode() const=0;
+
+ /**
+ Sets the flash mode.
+
+ Triggers a KUidECamEventCameraSettingFlashMode event to all camera
+ MCameraObserver2 clients.
+
+ @param aMode
+ The required flash mode.
+ */
+ virtual void SetFlashMode(CCamera::TFlash aMode)=0;
+
+ /**
+ Gets whether the flash red eye reduction is switched on.
+
+ @return The present state - ETrue for switched on and EFalse for switched off.
+ */
+ virtual TBool RedEyeReduceOn() const=0;
+
+ /**
+ Sets the flash red eye reduction on or off.
+
+ Triggers a KUidECamEventCameraSettingFlashRedEyeReduce event to all camera
+ MCameraObserver2 clients.
+
+ @param aState
+ The required state ETrue for switching it on and EFalse for switching it off.
+ */
+ virtual void SetRedEyeReduceOn(TBool aState)=0;
+
+ /**
+ Get flash compensation steps as integers multiplied by KECamFineResolutionFactor.
+ For example 0.5 EV is 50.
+
+ @param aFlashCompensationSteps
+ an RArray of integers which is populated on return to reflect the supported
+ flash compensation steps.
+
+ @param aInfo
+ an TValueInfo reference, which establishes the organization of the returned data.
+
+ @see TValueInfo
+
+ @leave KErrNoMemory Out of memory.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+ When camera device is incapable of revealing the flash compensation steps supported,
+ it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty
+ array should be returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const=0;
+
+ /**
+ @deprecated Use TInt GetFlashCompensationStep(TInt& aFlashCompensationStep);
+
+ Get current flash power compensation step.
+
+ @return current flash compensation step.
+ */
+ virtual TInt FlashCompensationStep() const=0;
+
+ /**
+ Get current flash power compensation step.
+
+ @param aFlashCompensationStep
+ Reference to the current flash power compensation step.
+
+ @return system wide error code.
+ */
+ virtual TInt GetFlashCompensationStep(TInt& aFlashCompensationStep) const=0;
+
+ /**
+ Set current flash compensation step as an integer multiplied by KECamFineResolutionFactor.
+ For example to set a compensation of -0.3 EV, one should use a parameter with value -30.
+ All clients receive a KUidECamEventCameraSettingFlashCompensationStep event, when the value has changed.
+
+ @param aFlashCompensationStep
+ a new value for the flash compensation step.
+ */
+ virtual void SetFlashCompensationStep(TInt aFlashCompensationStep)=0;
+
+ /**
+ Get current flash power compensation range measured in a already selected compensation step.
+ @note This range may change if a different compensation step is selected.
+ For example if flash compensation range is in the range -1EV 1.5EV and the selected flash compensation
+ step is selected to be 0.3 EV, the result of this call will be
+ aNegativeCompensation = -3 and aPositiveCompensation = 5.
+ as there can be only three full steps for negative compensation (1/0.3) and five for flash power boost (1.5/0.3).
+ In this way developers, having pre-selected a step value from the supported set, would need to provide
+ just the multplier (in steps) and the direction (the sign). Steps are always assumed integers.
+
+ @param aNegativeCompensation
+ reference to an integer returning the maximum number of steps available for negative compensation.
+
+ @param aPositiveCompensation
+ reference to an integer returning the maximum number of steps available for positive compensation.
+ */
+ virtual void GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const=0;
+
+ /**
+ @deprecated Use TInt GetFlashCompensation(TInt& aFlashCompensation);
+
+ Get the current flash compensation value as integer steps. Positive values boost flash power,
+ negative reduce flash power. The change is not cumulative i.e. the change is stateless.
+ Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+
+ @note if returned value is 2 (compensation steps) and the current flash compensation step is 0.3 EV,
+ then the actual compensation effect will be 0.6 EV.
+
+ @return the current number compensation steps as an integer.
+ */
+ virtual TInt FlashCompensation() const=0;
+
+ /**
+ Get the current flash compensation value as integer steps. Positive values boost flash power,
+ negative reduce flash power. The change is not cumulative i.e. the change is stateless.
+ Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+
+ @note if retrieved value is 2 (compensation steps) and the current flash compensation step is 0.3 EV,
+ then the actual compensation effect will be 0.6 EV.
+
+ @param aFlashCompensation
+ Reference to the current number of compensation steps as an integer.
+
+ @return system wide error code.
+ */
+ virtual TInt GetFlashCompensation(TInt& aFlashCompensation) const=0;
+
+ /**
+ Set the current flash compensation value as integer steps.
+ Positive values increase power, negative reduce power. The change is not cumulative i.e. the change is stateless.
+ Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+ Triggers a KUidECamEventCameraSettingFlashCompensation event.
+
+ @param aFlashCompensationSteps
+ a required compensation steps - negative value reduce the flash power
+ positive boosts up the flash power.
+ */
+ virtual void SetFlashCompensation(TInt aFlashCompensationSteps)=0;
+
+ /**
+ Check whether there is an external flash source.
+
+ @return ETrue if an external flash source is present, EFalse otherwise
+ */
+ virtual TBool IsExternalFlashPresent() const=0;
+
+ /**
+ Gets the current discrete manual flash power levels supported by the device in range 0-100
+ as a percentage of maximum power level.
+
+ @param aManualFlashPowerLevels
+ An empty array of TInt which would be populated by the implementation with
+ the specific supported values. If the array is empty on return,
+ the camera does not support this functionality.
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @leave KErrNoMemory Out of memory.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+ When camera device is incapable of revealing the manual flash power levels supported,
+ it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty
+ array should be returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const=0;
+
+ /**
+ Gets the current manual flash power level on the device.
+
+ @return the current manual flash power level as a value in the range [0:100].
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt ManualFlashPowerLevel() const=0;
+
+ /**
+ Sets the current manual flash power level on the device.
+ Triggers a KUidECamEventCameraSettingFlashManualPower event to all MCameraObserver2 clients.
+
+ @param aManualFlashPowerLevel
+ one of the values returned in GetManualFlashPowerLevelsL().
+ */
+ virtual void SetManualFlashPowerLevel(TInt aManualFlashPowerLevel)=0;
+
+ /**
+ Get Supported exposure modes - bitfields of CCamera::TExposure
+
+ @return the set of supported exposure modes.
+ */
+ virtual TInt SupportedExposureModes() const=0;
+
+ /**
+ Gets the currently set exposure setting value.
+
+ @return The currently set exposure setting value.
+ */
+ virtual CCamera::TExposure ExposureMode() const=0;
+
+ /**
+ Sets the exposure mode of the device.
+
+ Triggers a KUidECamEventCameraSettingExposureMode event to all MCameraObserver2 clients.
+
+ @param aExposureMode
+ The required exposure adjustment.
+ */
+ virtual void SetExposureMode(CCamera::TExposure aExposureMode)=0;
+
+ /**
+ Get exposure compensation steps as integers multiplied by KECamFineResolutionFactor.
+ For example 0.3 EV is 30.
+
+ @param aExposureCompensationSteps
+ an RArray of integers which is populated to reflect the supported
+ exposure compensation steps, all values have been multiplied by KECamFineResolutionFactor before
+ truncated to integers.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+ When camera device is incapable of revealing the exposure compensation steps supported,
+ it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty
+ array should be returned and TValueInfo should be ENotActive, and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const=0;
+
+ /**
+ @deprecated Use TInt GetExposureCompensationStep(TInt& aExposureCompensationStep);
+
+ Get current exposure compensation step.
+
+ @return current exposure compensation step.
+ */
+ virtual TInt ExposureCompensationStep() const=0;
+
+ /**
+ Get current exposure compensation step.
+
+ @param aExposureCompensationStep
+ Reference to the current exposure compensation step.
+
+ @return system wide error code.
+ */
+ virtual TInt GetExposureCompensationStep(TInt& aExposureCompensationStep) const=0;
+
+ /**
+ Set current exposure compensation step as an integer multiplied by KECamFineResolutionFactor.
+ All MCameraObserver2 clients receive a KUidECamEventCameraSettingExposureCompensationStep event,
+ when the value has changed.
+
+ @param aExposureCompensationStep
+ a new value for the exposure compensation step.
+ */
+ virtual void SetExposureCompensationStep(TInt aExposureCompensationStep)=0;
+
+ /**
+ Get current exposure compensation range in steps. It depends on the previously
+ selected exposure compensation step.
+
+ @param aNegativeCompensation
+ reference to an integer returning the maximum number of steps
+ available for negative compensation.
+
+ @param aPositiveCompensation
+ reference to an integer returning the maximum number of steps
+ available for positive compensation.
+
+ @see GetFlashCompensationRangeInSteps()
+ */
+ virtual void GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const=0;
+
+ /**
+ @deprecated Use TInt GetExposureCompensation(TInt& aExposureCompensation);
+
+ Get the current exposure compensation value as integer steps. Positive values increase exposure times,
+ negative reduce exposure times. The change is not cumulative i.e. the change is stateless.
+ Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+
+ @note if returned value is 2 (compensation steps) and the current exposure compensation step is 0.3 EV,
+ then the actual compensation effect will be 0.6 EV.
+
+ @return current number compensation steps as an integer.
+ */
+ virtual TInt ExposureCompensation() const=0;
+
+ /**
+ Get the current exposure compensation value as integer steps. Positive values increase exposure times,
+ negative reduce exposure times. The change is not cumulative i.e. the change is stateless.
+ Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
+
+ @note if retrieved value is 2 (compensation steps) and the current exposure compensation step is 0.3 EV,
+ then the actual compensation effect will be 0.6 EV.
+
+ @param aExposureCompensation
+ Reference to the current number of compensation steps as an integer.
+
+ @return system wide error code.
+ */
+ virtual TInt GetExposureCompensation(TInt& aExposureCompensation) const=0;
+
+ /**
+ Set the current exposure compensation value as integer steps.
+ Triggers a KUidECamEventCameraSettingExposureCompensation event to all MCameraObserver2 clients.
+
+ @param aExposureCompensationSteps
+ a required compensation value negative value reduce the exposure time
+ positive increases the exposure time.
+
+ */
+ virtual void SetExposureCompensation(TInt aExposureCompensationSteps)=0;
+
+ /**
+ Gets camera supported set of white balance adjustments.
+
+ @return bitfield of all supported CCamera::TWhiteBalance values.
+ */
+ virtual TInt SupportedWhiteBalanceModes() const=0;
+
+ /**
+ Gets the current white balance value.
+
+ @return The current white balance value.
+ */
+ virtual CCamera::TWhiteBalance WhiteBalanceMode() const=0;
+
+ /**
+ Sets the white balance adjustment of the device.
+
+ No effect if this is not supported, see TCameraInfo::iWhiteBalanceModesSupported.
+ Triggers a KUidECamEventCameraSettingWhiteBalanceMode event to all MCameraObserver2 clients.
+
+ @param aWhiteBalanceMode
+ The required white balance mode.
+ */
+ virtual void SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)=0;
+
+ /**
+ Gets the current state for aperture and exposure lock.
+
+ @return ETrue if aperture and exposure values are locked together,
+ EFalse if these are not locked.
+ */
+ virtual TBool ApertureExposureLockOn() const=0;
+
+ /**
+ Sets the current state for aperture and exposure lock.
+ Triggers a KUidECamEventAELock event to all MCameraObserver2 clients.
+
+ @param aAELock
+ a value whether to lock exposure and aperture together.
+ */
+ virtual void SetApertureExposureLockOn(TBool aAELock)=0;
+
+ /**
+ Gets the current state for button clicking sound effect.
+
+ @return boolean, ETrue to switch clicking sound on, EFalse sound off
+ */
+ virtual TBool ShootClickOn() const=0;
+
+ /**
+ Sets the button clicking sound effect on /off. Triggers a KUidECamEventSoundClick event
+ to all MCameraObserver2 clients.
+
+ @param aShootClickOn
+ boolean, ETrue to switch clicking sound on, EFalse sound is switched off.
+ */
+ virtual void SetShootClickOn(TBool aShootClickOn)=0;
+
+ /**
+ Get camera supported timer values. Active only when drive mode EDriveModeTimed.
+ Time is in microseconds. As time interval is expected to be relatively short,
+ integer value is considered sufficient.
+
+ @param aTimerIntervals
+ an RArray of integers which is populated to reflect the supported
+ timer interval steps.
+
+ @param aInfo
+ an TValueInfo reference, which establishes the organization of
+ the returned data.
+
+ @see TValueInfo
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const=0;
+
+ /**
+ Get current timer value. Active only when drive mode is EDriveModeTimed.
+ Timer resolution is in microseconds.
+
+ @return current time interval value.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt TimerInterval() const=0;
+
+ /**
+ Set current timer value. Active only when drive mode EDriveModeTimed.
+ This is the time interval (delay) in microseconds between user pressing the button and image is taken.
+ The setting of the value triggers a KUidECamEventCameraSettingTimerInterval event
+ to all MCameraObserver2 clients.
+
+ @param aTimerInterval
+ The selected timer interval in microseconds
+ */
+ virtual void SetTimerInterval(TInt aTimerInterval)=0;
+
+ /**
+ Get camera supported time lapse period range. Active only when drive mode EDriveModeTimeLapse.
+ The time lapse is denoted as the uniform time period between consecutive frames.
+
+ @param aTimeLapseMin
+ The minimum time value.
+
+ @param aTimeLapseMax
+ The maximum time value.
+ */
+ virtual void GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const=0;
+
+ /**
+ Get current time lapse value. Active only when drive mode EDriveModeTimeLapse.
+ The time lapse is denoted as the uniform time period
+ between consecutive frames and operation is configurable by its start, end and a fixed interval.
+ @param aStart
+ the start of the timelapse period
+ @param aEnd
+ the end of the timelapse period; start < end.
+ @param aInterval
+ the set parameter between two successive snapshots.
+ */
+ virtual void GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const=0;
+
+ /**
+ Set current time lapse value. Active only when drive mode EDriveModeTimeLapse.
+ The time lapse is denoted as the uniform time period between consecutive frames.
+ Setting triggers a KUidECamEventCameraSettingTimeLapse event to all MCameraObserver2 camera clients.
+
+ @param aStart
+ the start of the timelapse period.
+ @param aEnd
+ the end of the timelapse period; start < end.
+ @param aInterval
+ the set parameter between two successive snapshots.
+ */
+ virtual void SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval)=0;
+
+ /**
+ Get current picture orientation.
+
+ @return a TPictureOrientation value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TPictureOrientation PictureOrientation() const=0;
+
+ /**
+ Set a new picture orientation
+ This triggers a KUidECamEventCameraSettingPictureOrientation event to all MCameraObserver2 clients.
+
+ @param aOrientation
+ a value of TPictureOrientation denoting the new orientation.
+ */
+ virtual void SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)=0;
+
+ /**
+ Get supported pixel aspect ratio.
+
+ @return a bitfield of all supported TPixelAspectRatio values.
+ */
+ virtual TInt SupportedPixelAspectRatios() const=0;
+ /**
+ Get current pixel aspect ratio.
+
+ @return a TPixelAspectRatio value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TPixelAspectRatio PixelAspectRatio() const=0;
+
+ /**
+ Set a new pixel aspect ratio.
+ This triggers a KUidECamEventPixelAspectRatio event to all MCameraObserver2 clients.
+
+ @param aPixelAspectRatio
+ a value of TPixelAspectRatio denoting the new pixel aspect ratio.
+ */
+ virtual void SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)=0;
+
+ /**
+ Get supported YUV ranges.
+
+ @return a bitfileld of all supported TYuvRange values.
+ */
+ virtual TInt SupportedYuvRanges() const=0;
+
+ /**
+ Get the current YUV range.
+
+ @return a TYuvRange value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TYuvRange YuvRange() const=0;
+
+ /**
+ Set a new YUV range.
+ This triggers a KUidECamEventYuvRange event to all MCameraObserver2 clients.
+
+ @param aYuvRange
+ a value of TYuvRange denoting the new YUV range.
+ */
+ virtual void SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)=0;
+
+ /**
+ Get the number of images captured normally under EDriveModeBurst condition.
+ @note: due to memory or image size limitations the actual number may be less.
+
+ @return the number of images set to capture in burst mode.
+ */
+ virtual TInt BurstImages() const=0;
+
+ /**
+ Set the number of images captured normally under EDriveModeBurst condition.
+ Triggers a KUidECamEventBurstImages event to all MCameraObserver2 clients.
+ @note: due to memory or image size limitations the actual number may be less.
+
+ @param aImages
+ the number of images set to capture in burst mode.
+
+ @note Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or PerformantStopVideoCaptureL())
+ if an image/video capture is still outstanding, this method may report error KErrInUse.
+ */
+ virtual void SetBurstImages(TInt aImages)=0;
+
+ /**
+ Gets the optical zoom levels.
+
+ @param aOpticalZoomSteps
+ Array to hold optical zoom values multiplied by KECamFineResolutionFactor to retain precision.
+ So that if zoom is not supported the array will return a single element of value
+ KECamFineResolutionFactor.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @note Such approach allows for support for both linear and non-linear zoom steps.
+ When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const=0;
+
+ /**
+ Gets the currently set zoom value.
+
+ @return The currently set optical zoom value. The value is multiplied by
+ KECamFineResolutionFactor to retain precision.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt OpticalZoom() const=0;
+
+ /**
+ Sets the zoom using a specific value. Triggers a KUidECamEventCameraSettingOpticalZoom
+ event to all MCameraObserver2 clients.
+
+ @param aOpticalZoom
+ Required zoom value.
+ */
+ virtual void SetOpticalZoom(TInt aOpticalZoom)=0;
+
+ /**
+ Gets the digital zoom levels.
+
+ @param aDigitalZoomSteps
+ Array to hold digital zoom values multiplied by KECamFineResolutionFactor to retain precision.
+ So that if zoom is not supported the array will return a single element of value
+ KECamFineResolutionFactor.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @note Such approach allows for support for both linear and non-linear zoom steps.
+ When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive
+ and the corresponding getter/setters for this feature should not be used.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo) const=0;
+
+ /**
+ Gets the currently set digital zoom value.
+
+ @return The currently set digital zoom value. The value is multiplied by
+ KECamFineResolutionFactor to retain precision.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt DigitalZoom() const=0;
+
+ /**
+ Sets the digital zoom value. Triggers a KUidECamEventCameraSettingDigitalZoom event
+ to all MCameraObserver2 clients.
+
+ @param aDigitalZoom
+ Required zoom value.
+
+ */
+ virtual void SetDigitalZoom(TInt aDigitalZoom)=0;
+
+ /**
+ Checks whether exposure value is locked or not.
+
+ @return whether exposure value is locked or not.
+ ETrue if locked, EFalse otherwise.
+ */
+ virtual TBool ExposureLockOn() const=0;
+
+ /**
+ Sets exposure lock state. Triggers a KUidECamEventCameraSettingExposureLock event
+ to all MCameraObserver2 clients.
+
+ @param aState
+ Required new state.
+ */
+ virtual void SetExposureLockOn(TBool aState)=0;
+
+ /**
+ Checks whether AutoFocus value is locked or not.
+
+ @return whether AutoFocus value is locked or not.
+ ETrue if locked, EFalse otherwise.
+ */
+ virtual TBool AutoFocusLockOn() const=0;
+
+ /**
+ Sets autofocus lock state. Triggers a KUidECamEventCameraSettingAutoFocusLock event
+ to all MCameraObserver2 clients.
+
+ @param aState
+ Required new state.
+ */
+ virtual void SetAutoFocusLockOn(TBool aState)=0;
+
+ /**
+ Gets an array of all the advanced settings parameters supported by the device.
+ These are identified by UIDs and relate to the set or subset of it of all defined settings UIDs.
+
+ @param aSettings
+ An empty array of TUids which would be populated by the implementation with
+ the UIDs of the supported parameters. If the array is empty on return,
+ the camera does not support any settings.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetSupportedSettingsL(RArray<TUid>& aSettings) const=0;
+
+ /**
+ Gets an array of all the advanced settings parameters currently active on the device.
+ These are identified by UIDs and relate to the set or subset of it of all supported
+ settings UIDs.
+
+ @param aActiveSettings
+ An empty array of TUids which would be populated by the implementation with
+ the active setting UIDs. If the array is empty on return,
+ the camera does not support any settings.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetActiveSettingsL(RArray<TUid>& aActiveSettings) const=0;
+
+ /**
+ Gets an array of all the advanced settings parameters currently disabled on the device.
+ These are identified by UIDs and relate to the set or subset of it of all supported
+ settings UIDs.
+
+ @param aDisabledSettings
+ An empty array of TUids which would be populated by the implementation with
+ the disabled setting UIDs. If the array is empty on return,
+ the camera does not support any settings.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const=0;
+
+ /**
+ Retrieves the state for automatic size selection option. Default value is EFalse.
+
+ @return ETrue if the automatic selection is switched on. Default value is EFalse.
+ */
+ virtual TBool AutomaticSizeSelectionChangeOn() const=0;
+
+ /**
+ Allow camera to proactively change image size due external factors.
+ Default value is EFalse. Triggers a KUidECamEventCameraSettingAutomaticSizeSelection event notification.
+ @param aSetOn
+ whether the option should be switched on
+ */
+ virtual void SetAutomaticSizeSelectionChangeOn(TBool aSetOn)=0;
+
+ /**
+ Retrieves the timeout values camera supported by the camera when in continuous auto focus mode.
+ Timeouts are in microseconds.
+
+ @param aTimeouts
+ An empty array to hold timeout values.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive
+ and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const=0;
+
+ /**
+ Gets the current value for continuous autofocus timeout. Timeouts are in microseconds.
+
+ @return the timeout value in microseconds.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt ContinuousAutoFocusTimeout() const=0;
+
+ /**
+ Sets new value for continuous autofocus timeout. Timeouts are in microseconds.
+ All MCameraObserver2 clients of the camera receive a
+ KUidECamEventCameraSettingsContinuousAutoFocusTimeout
+ event notification when timeout value is changed.
+
+ @param aTimeout
+ a new timeout value in microseconds.
+ */
+ virtual void SetContinuousAutoFocusTimeout(TInt aTimeout)=0;
+
+ /**
+ Gets all supported stabilization effects on the device.
+
+ @return an integer - a bitfield of all supported TStabilizationEffect values.
+ */
+ virtual TInt SupportedStabilizationEffects() const=0;
+
+ /**
+ Gets current active stabilization effect on the device.
+
+ @return a TStabilizationEffect value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TStabilizationEffect StabilizationEffect() const=0;
+
+ /**
+ Sets a specific stabilization effect on the device.
+ When a value is set, MCameraObserver2 clients for that camera will receive a
+ KUidECamEventCameraSettingsStabilizationEffect event notification.
+
+ @param aEffect
+ stabilization effect selection of type TStabilizationEffect.
+ */
+ virtual void SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)=0;
+
+ /**
+ Gets all supported stabilization algorithm values on the device.
+
+ @return an integer - a bitfield of all supported TStabilizationAlgorithmComplexity values.
+ */
+ virtual TInt SupportedStabilizationComplexityValues() const=0;
+
+ /**
+ Gets current active stabilization algorithm selection on the device.
+
+ @return a TStabilizationAlgorithmComplexity value.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity StabilizationComplexity() const=0;
+
+ /**
+ Sets a specific stabilization algorithm on the device.
+ When a value is set, MCameraObserver2 clients for that camera will receive a
+ KUidECamEventSettingsStabilizationAlgorithmComplexity event notification.
+
+ @param aComplexity
+ stabilization effect selection of type TStabilizationAlgorithmComplexity.
+ */
+ virtual void SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)=0;
+
+ /**
+ Gets the units in which the white balance is measured on the device. The methods used to get
+ or set these differ depending on the supported unit type.
+ It is expected that a device will support only a single type or none.
+
+ @return a value of TWBUnits type.
+ */
+ virtual CCamera::CCameraAdvancedSettings::TWBUnits SupportedWBUnits() const=0;
+
+ /**
+ Get white balance value represented as a RGB triplet (TRgb)
+
+ @param aValue
+ a reference to TRgb object which will contain the current white balance.
+ */
+ virtual void GetWBRgbValue(TRgb& aValue) const=0;
+
+ /**
+ Set white balance value using a RGB triplet (TRgb).
+ Change in value causes an event notification KUidECamEventCameraSettingsWBValue
+ to be sent to all MCameraObserver2 clients of this camera.
+
+ @param aValue
+ a const reference to TRgb object, which contains the new white balance.
+ */
+ virtual void SetWBRgbValue(const TRgb& aValue)=0;
+
+ /**
+ Get the white balance values, as temperature measured in Kelvin, supported on the device.
+
+ @param aWBColorTemperatures
+ A reference to an empty array of TInt which would be populated by the implementation with
+ the specific supported values.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const=0;
+
+ /**
+ Get the white balance as a temperature in Kelvin.
+
+ @return current white balance value as a temperature in Kelvins.
+
+ @note In case there is an error, a negative error value from system wide error should be returned.
+ */
+ virtual TInt WBColorTemperature() const=0;
+
+ /**
+ Set white balance value using a temperature, measured in Kelvin.
+ Change in value causes an event notification KUidECamEventCameraSettingsWBValue
+ to be sent to all MCameraObserver2 clients of this camera.
+
+ @param aWBColorTemperature
+ the new white balance value in Kelvin.
+ */
+ virtual void SetWBColorTemperature(TInt aWBColorTemperature)=0;
+ };
+
+
+/**
+Mixin class for implementation by providers of some enhanced functionalities of the
+Advanced Settings Camera Extension API.
+
+@publishedPartner
+@released
+*/
+class MCameraAdvancedSettings2
+ {
+
+public:
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+
+ /**
+ Checks whether the flash is ready.
+
+ @param aReady
+ A reference to a boolean set by the implementation to ETrue if the flash is ready,
+ EFalse otherwise.
+
+ @return KErrNotSupported if the implementation of this method is not supported.
+ */
+ virtual TInt IsFlashReady(TBool& aReady) const=0;
+
+ /**
+ Get the number of focus steps for current focus mode.
+
+ @param aFocusModeSteps
+ A reference to an empty array of TInt which would be populated by the implementation with
+ the specific supported values.
+
+ @param aInfo
+ a reference to TValueInfo, which establishes the type of the returned data.
+
+ @leave KErrNotSupported if the implementation of this method is not supported. May also leave as a result of other system errors.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+ */
+ virtual void GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const=0;
+ };
+
+/**
+Mixin class for implementation by providers of 'some of the enhanced functionalities' of the
+Advanced Settings Camera Extension API.
+
+@publishedPartner
+@released
+*/
+class MCameraAdvancedSettings3
+ {
+
+public:
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+
+ /**
+ Gets all supported ISO types on the device.
+
+ @param aSupportedISORateTypes
+ A reference to an integer which is a bitfield of all supported TISORateType values.
+ EISONone means feature is not supported.
+
+ @leave May leave as a result of some error.
+ */
+ virtual void GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const=0;
+
+ /**
+ Set the type of ISO rate and the exposure parameter or value specified.
+
+ @param aISORateType
+ The type of ISO rate to be set.
+
+ @param aParam
+ Depending on the value of aISORateType, possible values of aParam are one of the following:-
+ The value of ISO rate to be used in case of manual type of ISO rate (EISOManual).
+ OR
+ Redundant parameter in case of unprioritised type of auto ISO (EISOAutoUnPrioritised). It is left to the camera hardware/firmware
+ to decide how the ISO rate is selected. No priority regarding exposure is specified.
+ OR
+ Highest ISO rate to be picked by the camera while deciding for the best exposure in case of ISO prioritised
+ type of auto ISO (EISOAutoISOPrioritised). ISO rate closest to this (and lower) may be used so that best possible exposure is achieved.
+ OR
+ Slowest shutter speed to be picked by the camera while deciding for the best exposure in case of shutter speed
+ prioritised type of auto ISO (EISOAutoShutterSpeedPrioritised). After using this shutter speed, ISO rate is chosen by the camera to achieve
+ proper exposure. Shutter speed closest to this (and faster) may be used so that best possible exposure is achieved.
+ OR
+ Minimum aperture opening (deepest depth of field) to be picked by the camera while deciding
+ for the best exposure in case of aperture prioritised type of auto ISO (EISOAutoAperturePrioritised). After using this aperture opening, ISO
+ rate is chosen by the camera to achieve proper exposure. Aperture opening closest to this (and wider) may be
+ used to achieve best possible exposure.
+
+ @note Triggers KUidECamEventCameraSettingIsoRateType to all MCameraObserver2 clients of the camera.
+ Uses HandleEvent to report the result or any possible error.
+ */
+ virtual void SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)=0;
+
+ /**
+ Get the type of ISO rate, exposure parameter and value set.
+
+ @param aISORateType
+ A reference to the type of ISO rate set. EISONone means feature is not supported.
+
+ @param aParam
+ Depending on the value of aISORateType, possible values of aParam are one of the following:-
+ A reference to the redundant parameter in case of manual type of ISO rate(EISOManual)
+ OR
+ A reference to the redundant parameter in case of unprioritised type of auto ISO(EISOAutoUnPrioritised)
+ OR
+ A reference to the highest ISO rate that may be picked up in case of ISO prioritised type of auto ISO(EISOAutoISOPrioritised)
+ OR
+ A reference to the slowest shutter speed that may be picked up in case of shutter speed prioritised type of auto ISO(EISOAutoShutterSpeedPrioritised)
+ OR
+ A reference to the minimum aperture opening that may be picked up in case of aperture prioritised type of auto ISO(EISOAutoAperturePrioritised)
+
+ @param aISORate
+ A reference to the value of ISO rate currently being used, if camera device is capable of doing that.
+ Otherwise KErrNotFound should be retrieved indicating the incapability of camera.
+
+ @leave May leave as a result of some other error.
+
+ @note Since camera hardware may be incapable of providing the actual ISO value when one of the auto ISO type has
+ been set, then, in these cases, the 3rd argument should be retrieved as KErrNotFound.
+ */
+ virtual void GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const=0;
+
+ /**
+ Provide reference screen for orientation information.
+
+ @param aScreenDevice
+ A reference to the screen device.
+
+ @note For consistency, when DSA view finder runs, it also provides a screen device. So, the DSA view finder's internal implementation
+ should call this method with the screen device passed ( 2nd argument to DSA view finder) to avoid disparity in knowing the refeence screen.
+ Triggers KUidECamEventCameraSettingReferenceScreen to all MCameraObserver2 clients of the camera.
+ Uses HandleEvent to report the result or any possible error.
+ */
+ virtual void SetReferenceScreen(CWsScreenDevice& aScreenDevice)=0;
+
+ /**
+ Get the digital zoom steps for the still image when a particular image format and size are specified.
+
+ @param aDigitalZoomSteps
+ A reference to an empty array of TInt to hold digital zoom step values for still image and multiplied by
+ KECamFineResolutionFactor to retain precision. If list returned is empty, this means feature is not supported.
+
+ @param aInfo
+ A reference to TValueInfo, which establishes the type of the returned data.
+
+ @param aSizeIndex
+ A value providing the size index which must be in the range 0 to TCameraInfo::iNumImageSizesSupported-1
+ inclusive.
+
+ @param aFormat
+ A value providing the image format which must be one of the formats supported. (see
+ TCameraInfo::iImageFormatsSupported)
+
+ @param aIsInfluencePossible
+ If True, signals that digital zoom step values may be influenced by some hardware factor like stabilization etc.
+ If False, no influence possible.
+
+ @leave KErrNoMemory Out of memory. May leave with any other error code.
+
+ @note This method retrieves the supported digital zoom steps irrespective of any stabilization influence.
+ In case of stabilization etc. influence, the setting function should set the best possible digital zoom value
+ and return error KErrECamDigitalZoomLimited along with dedicated event.
+
+ @note When camera device doesn't support this feature, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+
+ @note Implementation recommendation for old methods which are used to retrieve the supported digital zoom values, is
+ to provide only safe values suitable in every cases.
+ */
+ virtual void GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aSizeIndex,
+ CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const=0;
+
+ /**
+ Get the digital zoom steps for the video when a particular video frame format, size and rate are specified.
+
+ @param aDigitalZoomSteps
+ A reference to an empty array of TInt to hold digital zoom step values for video and multiplied by
+ KECamFineResolutionFactor to retain precision. If list returned is empty, this means feature is not supported.
+
+ @param aInfo
+ A reference to TValueInfo, which establishes the type of the returned data.
+
+ @param aFrameRateIndex
+ A value providing the rate index must be in the range 0 to TCameraInfo::iNumVideoFrameRatesSupported-1
+ inclusive.
+
+ @param aSizeIndex
+ A value providing the size index which must be in the range 0 to TCameraInfo::iNumVideoFrameSizesSupported-1
+ inclusive.
+
+ @param aFormat
+ A value providing the format which must be one of the video frame formats supported. (see
+ TCameraInfo::iVideoFrameFormatsSupported)
+
+ @param aIsInfluencePossible
+ If True, signals that digital zoom step values may be influenced by some hardware factor like stabilization etc.
+ If False, no influence possible.
+
+ @param aExposure
+ The exposure mode.
+
+ @leave KErrNoMemory Out of memory. May leave with any other error code.
+
+ @note This method retrieves the supported digital zoom steps irrespective of any stabilization influence.
+ In case of stabilization etc. influence, the setting function should set the best possible digital zoom value
+ and return error KErrECamDigitalZoomLimited along with dedicated event.
+
+ @note When camera device doesn't support this, empty array should be returned and TValueInfo should be ENotActive,
+ and the corresponding getter/setters for this feature should not be used.
+
+ @note Implementation recommendation for old methods which are used to retrieve the supported digital zoom values, is
+ to provide only safe values suitable in every cases.
+ */
+ virtual void GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aFrameRateIndex,
+ TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible, CCamera::TExposure aExposure) const=0;
+ /**
+ Retrieves the pre capture warnings supported for a given camera mode
+
+ @param aCameraMode
+ Desired camera mode for which the supported pre capture warnings may be retrieved.
+
+ @param aPreCaptureWarningSupported
+ A bitfield of all supported TPreCaptureWarning to be issued in the given camera mode.
+ If no pre capture warning supported for the given camera mode, EPCWNone is retrieved.
+
+ @leave May leave with any error.
+ */
+ virtual void GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode aCameraMode, TInt& aPreCaptureWarningSupported) const=0;
+
+ /**
+ Subscribe in order to receive event which indicates warnings on occurrence of some specific unfavourable
+ conditions before image/video capture.
+
+ @param aPreCaptureWarning
+ A bitfield specifying all the TPreCaptureWarning types to be subscribed for.
+
+ @note When any of the subscribed warnings (represented by aPreCaptureWarning) get generated by the camera device,
+ event KUidECamEventCameraSettingPreCaptureWarning is issued. TECAMEvent2 class should be used in order to
+ provide the status of every PreCaptureWarning.
+
+ @leave May leave with any error.
+ */
+ virtual void SubscribeToPreCaptureWarningL(TInt aPreCaptureWarning)=0;
+
+ /**
+ Unsubscribe so that further events are not received when warnings get issued.
+
+ @leave May leave with any error.
+ */
+ virtual void UnSubscribePreCaptureWarningL()=0;
+
+ /**
+ Get the status of every warnings defined.
+
+ @param aPreCaptureWarning
+ A reference to the integer - bitfield representing all the TPreCaptureWarning types issued.
+
+ @leave May leave with any error.
+
+ @note This method may be called after receiving the event KUidECamEventCameraSettingPreCaptureWarning OR
+ user may also opt for polling on this.
+ */
+ virtual void GetPreCaptureWarningL(TInt& aPreCaptureWarning) const=0;
+
+ /**
+ Retrieve the different supported AF assistant light.
+
+ @param aSupportedAFAssistantLight
+ A reference to integer - bitfield indicating the supported AF assistant light.
+ If EAFAssistantLightOff, this means AF assistant light is not supported.
+ If EAFAssistantLightManualOn, then manual AF assistant light is supported.
+ If EAFAssistantLightAuto, auto assistant light is supported.
+ If combination of EAFAssistantLightManualOn||EAFAssistantLightAuto , then both manual and Auto assistant light are supported.
+
+ @leave May leave with any error.
+ */
+ virtual void GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const=0;
+
+ /**
+ Get the type ( and state) of AF assistant light currently set.
+
+ @param aAFAssistantLight
+ A reference to AF assistant light.
+ If EAFAssistantLightOff, then manual and auto assistant light are switched off.
+ If EAFAssistantLightManualOn, manual assistant light is switched on.
+ If EAFAssistantLightAuto, AF assistant light is set to auto.
+
+ @leave May leave with any error.
+ */
+ virtual void GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& aAFAssistantLight) const=0;
+
+ /**
+ Set a particular type ( and state) of AF assistant light.
+
+ @param aAFAssistantLight
+ Type of AF assistant light to be set.
+ If EAFAssistantLightOff, switch off the manual or auto assistant light.
+ If EAFAssistantLightManualOn, manually switch on the assistant light.
+ If EAFAssistantLightAuto, camera will automatically switch it on/off as per the conditions.
+
+ @note Triggers KUidECamEventCameraSettingAFAssistantLight to all MCameraObserver2 clients of the camera.
+ Uses HandleEvent to report the result or any possible error.
+ */
+ virtual void SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)=0;
+ };
+
+/**
+Mixin class for implementation by providers of 'advanced camera feature extensions' of the
+Advanced Settings Camera Extension API.
+
+@publishedPartner
+@prototype
+*/
+class MCameraAdvancedSettings4
+ {
+
+public:
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+
+ /**
+ Retrieves the supported continuous zoom types.
+
+ @param aSupportedContinuousZoomType
+ Retrieves a bitfield of TUint which indicates the supported continuous zoom type as given by
+ CCamera::CCameraAdvancedSettings::TContinuousZoomType
+
+ @leave May leave with any error code.
+ */
+ virtual void GetSupportedContinuousZoomTypeL(TUint& aSupportedContinuousZoomType) const=0;
+
+ /**
+ Retrieves the minimum, current and maximum focal length in millimeters. This information is useful to find out
+ which zoom directions can be used on the fly.
+
+ @param aMinFocalLength
+ Minimum focal length if positive.
+ Error value if negative (for example, KErrNotFound if information not available).
+
+ @param aCurrentFocalLength
+ Current focal length if positive.
+ Error value if negative (for example, KErrNotFound if information not available).
+
+ @param aMaxFocalLength
+ Maximum focal length if positive.
+ Error value if negative (for example, KErrNotFound if information not available).
+
+ @leave May leave with any error code.
+ */
+ virtual void GetFocalLengthInfoL(TInt& aMinFocalLength, TInt& aCurrentFocalLength, TInt& aMaxFocalLength) const=0;
+
+ /**
+ Retrieves the total number of operation preferences supported by the implementation. Operation preferences are
+ specified in terms of performance vectors, that is, speed, quality, low memory consumption and low power consumption.
+
+ @param aNumOperationPreferenceSupported
+ Retrieves the number of operation preferences supported.
+
+ @leave May leave with any error code.
+ */
+ virtual void GetNumOperationPreferenceL(TUint& aNumOperationPreferenceSupported) const=0;
+
+ /**
+ Enumerate the available operation preferences.
+
+ @param aOperationPreferenceIndex
+ A particular index which represents an operation preference. The level of different performance vectors may be known
+ through other arguments. This varies from 0 to n-1, where n is given by GetNumOperationPreferenceL(n).
+
+ @param aSpeedLevel
+ A TPerformanceLevel which specifies the speed level related to the index aOperationPreferenceIndex.
+
+ @param aQualityLevel
+ A TPerformanceLevel which specifies the quality level related to the index aOperationPreferenceIndex.
+
+ @param aLowMemoryConsumptionLevel
+ A TPerformanceLevel which specifies the low memory consumption level related to the index aOperationPreferenceIndex.
+ The lower the memory consumption, the higher the level.
+
+ @param aLowPowerConsumptionLevel
+ A TPerformanceLevel which specifies the low power consumption level related to the index aOperationPreferenceIndex.
+ The lower the power consumption, the higher the level.
+
+ @note It is up to the implementation how the performance levels are achieved. For example, shutter opening, JPEQ quality
+ and parallel buffering in case of streamed image output can be controlled in order to provide the desired
+ performance.
+
+ @leave May leave with any error code.
+ */
+ virtual void EnumerateOperationPreferenceL(TUint aOperationPreferenceIndex, CCamera::CCameraAdvancedSettings::
+ TPerformanceLevel& aSpeedLevel, CCamera::CCameraAdvancedSettings::TPerformanceLevel& aQualityLevel,
+ CCamera::CCameraAdvancedSettings::TPerformanceLevel& aLowMemoryConsumptionLevel,
+ CCamera::CCameraAdvancedSettings::TPerformanceLevel& aLowPowerConsumptionLevel) const=0;
+
+ /**
+ Set a particular operation preference.
+
+ @param aOperationPreferenceIndex
+ An index which reveals a set of levels to be used for performance vectors, that is, speed, quality, low memory
+ consumption and low power consumption.
+
+ @note Event KUidECamEventCameraSettingOperationPreference is used to notify clients about setting an operation preference.
+ */
+ virtual void SetOperationPreference(TUint aOperationPreferenceIndex)=0;
+
+ /**
+ Get the current operation preference being used.
+
+ @param aOperationPreferenceIndex
+ Currently used operation preference index.
+
+ @leave May leave with any error code.
+ */
+ virtual void GetOperationPreferenceL(TInt& aOperationPreferenceIndex) const=0;
+
+ /**
+ Retrieves the event uids which the underlying implementation supports. The client may use these events notifications as
+ milestones in their application.
+
+ @param aSupportedEvents
+ Retrieves as array of TUid. Every member of the array represents a supported event uid. These events are ECAM
+ component wide.
+
+ @leave May leave with any error code.
+
+ @note This method may retrieve unrecognized events which may be introduced later on.
+ */
+ virtual void GetSupportedEventsL(RArray<TUid>& aSupportedEvents) const=0;
+
+ /**
+ Retrieves the indirect feature changes which occur because of a particular requested feature change.
+ Since the camera setting operation is asynchronous in nature, changing a particular camera feature, in certain cases,
+ involves indirectly changing another feature. In order to notify the ECam client about this indirect feature change,
+ event KUidECamEvent2IndirectFeatureChange is issued. After this notification, the client may use this method to retrieve
+ the full list of indirect feature changes.
+
+ @param aRequestedSetting
+ The actual requested feature change. This uid is supposed to be ECAM component wide and not restricted to
+ advanced camera settings.
+
+ @param aIndirectFeatureChanges
+ An array of uids which retrieves the indirect feature changes. These uids are supposed to be ECAM component wide
+ and not restricted to advanced camera settings.
+
+ @leave May leave with any error code.
+ */
+ virtual void GetIndirectFeatureChangesL(TUid aRequestedSetting, RArray<TUid>& aIndirectFeatureChanges) const=0;
+
+ /**
+ Retrieves the concrete factory handle for the continuous zoom implementation.
+
+ @param aImplFactoryPtr
+ The concrete factory handle for the continuous zoom implementation.
+
+ @leave May leave with any error code.
+ */
+ virtual void CreateContinuousZoomImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;
+ };
+
+/**
+Mixin class for implementation by providers of the Presets Camera Extension API.
+
+This API is used to simplify user - camera interaction by allowing simultaneous
+setting of various advanced camera hardware settings using a single parameter.
+
+A preset is identified by a single UID and relates to a known predefined outcome.
+For example the 'Night' Preset is used to set the camera into a night mode
+so that the user can take photos in dark conditions.
+
+The settings associated with a particular preset and their specific values and ranges
+are specific to each type of camera hardware and are therefore not defined by the API.
+
+@publishedPartner
+@released
+*/
+class MCameraPresets
+ {
+
+public:
+
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+
+ /**
+ Gets the presets supported by the device. These are identified by UIDs
+ and relate to a known expected outcome.
+ The settings associated with a particular preset and their specific values and ranges are
+ specific to each type of camera hardware and are therefore not defined by the API.
+
+ @param aPresets
+ An empty array of TUids which the API implementation must populate with the specific supported preset values. If the array is empty on return,
+ the camera does not support presets.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetSupportedPresetsL(RArray<TUid>& aPresets) const=0;
+
+ /**
+ Sets a specific preset supported by the camera.
+ All clients, implementing the MCameraObserver2 interface will receive a notification
+ with the UID of the specific preset, signalling a new preset has been selected.
+
+ @param aPreset
+ The UID of the new requested preset.
+
+ @note A particular preset is only active if it was established (through a call to
+ MCameraPresets ::SetPreset()) as the most recent operation affecting camera settings.
+ If some other camera setting is changed after calling MCameraPresets ::SetPreset()
+ then the preset is no longer active.
+ */
+ virtual void SetPreset(TUid aPreset)=0;
+
+ /**
+ Gets the preset that was established by the last call to MCameraPresets ::SetPreset()
+
+ @return The UID of the preset. If there is no active preset then the
+ returned value is KNullUid.
+
+ @note A particular preset is only active if it was established (through a call to
+ MCameraPresets ::SetPreset()) as the most recent operation affecting camera settings.
+ If some other camera setting is changed after calling MCameraPresets ::SetPreset()
+ then the preset is no longer active.
+ */
+ virtual TUid Preset() const=0;
+
+ /**
+ Gets all settings affected by the current preset. All settings that are related to
+ the preset in question will be included in the list, including any whose values
+ have not changed as a result of applying the preset.
+
+ @param aSettings
+ An empty array of TUids which the API implementation must populate with the specific settings.
+
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetAffectedSettingsL(RArray<TUid>& aSettings) const=0;
+
+ /**
+ Gets all settings associated with a specific preset. This function does not require a preset to have been set prior the call as in
+ GetAffectedSettingsL() function.
+ The returned array will contain the UIDs of all settings which are associated and
+ potentially affected by that particular preset.
+
+ @param aPreset
+ the UID of the preset in question.
+
+ @param aSettings
+ An empty array of TUids which would be populated by the implementation with
+ the UIDs of the settings associated with that preset.
+
+ @leave KErrArgument if the preset UID is not recognised
+ @leave KErrNoMemory Out of memory. May also leave as a result of other system errors.
+ */
+ virtual void GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const=0;
+ };
+
+/**
+Mixin class for implementation of extra methods of the Presets Camera Extension API.
+
+@publishedPartner
+@prototype
+*/
+class MCameraPresets2
+ {
+
+public:
+
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+
+ /**
+ Retrieves those settings for which ranges have been restricted in order to let the camera work in a given preset mode.
+ The client will be notified of range restrictions through uid KUidECamEventRangeRestricted. After receiving this
+ notification, the client may use this method to retrieve those settings whose ranges have been restricted.
+
+ @param aRangeRestrictedSettings
+ An array of uid which represents those settings whose ranges have been restricted. These settings are ECam
+ component wide. For each of the settings, the client can query about the restricted range as per the usual way.
+
+ @leave May leave with any error code.
+ */
+ virtual void GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const=0;
+
+ /**
+ Retrieves those settings which have been restricted (settings no longer supported) in order to let the camera work in a given preset mode.
+ The client will be notified of feature restrictions through uid KUidECamEventFeatureRestricted. After receiving this
+ notification, the client may use this method to retrieve these settings.
+
+ @param aFeatureRestrictedSettings
+ An array of uid which represents those settings which have been restricted. These settings are ECam
+ component wide.
+
+ @leave May leave with any error code.
+ */
+ virtual void GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const=0;
+
+ /**
+ Retrieves information about whether the preset unlock feature is supported or not. Unlocking the preset helps in making some
+ further changes in the setting after the camera works in a particular preset mode
+
+ @param aUnlockSupported
+ ETrue indicates preset unlock feature is supported.
+ EFalse indicates preset lock feature is not supported.
+
+ @leave May leave with any error code.
+ */
+ virtual void IsPresetUnlockSupportedL(TBool& aUnlockSupported) const=0;
+
+ /**
+ Locks the preset for any further setting changes.
+
+ @note Event KUidECamEventPresetLocked is used to notify clients that the preset has been locked.
+ */
+ virtual void LockPreset()=0;
+
+ /**
+ Unlocks the preset to apply further setting changes.
+
+ @note Event KUidECamEventPresetUnlocked is used to notify clients that the preset has been unlocked.
+ */
+ virtual void UnlockPreset()=0;
+ };
+
+/**
+Mixin class for implementation of extra methods of the Continuous Zoom API.
+
+@internalTechnology
+@prototype
+*/
+class MCameraContinuousZoom
+ {
+public:
+
+ /**
+ Passes both the continuous zoom observer and pointer to the continuous zoom class to the implementation so callbacks
+ can be sent to the client along with the continuous zoom handle.
+
+ @param aObserver
+ The reference to the continuous zoom observer.
+
+ @param aContinuousZoomHandle
+ The pointer to the continuous zoom class object.
+
+ @see MContinuousZoomObserver
+ */
+ virtual void SetContinuousZoomObserverAndHandle(MContinuousZoomObserver& aObserver, CCamera::CCameraContinuousZoom* aContinuousZoomHandle)=0;
+
+ /**
+ Starts the continuous zoom operation. Clients will receive MContinuousZoomObserver::ContinuousZoomProgress() callback for intermediate zoom factors
+ achieved. It is up to the implementation to choose the zoom factors for which it will issue this callback. Implementation will not use this callback to notify
+ reaching the target zoom factor. This will be done via MContinuousZoomObserver::ContinuousZoomComplete() callback.
+
+ @param aContinuousZoomParameters
+ The desired parameters to be used for the continuous zoom operation.
+
+ @note If the implementation does not support re-configuring of zoom parameters whilst an existing continuous zoom operation is active then
+ StartContinuousZoomL() will leave with KErrInUse.
+
+ @note If client has selected EDirectionTele zoom direction and the current zoom factor is greater than the target zoom factor, StartContinuousZoomL()
+ will leave with KErrArgument. Similarly, StartContinuousZoomL() will also leave with KErrArgument if client has selected EDirectionWide zoom
+ direction and current zoom factor is less than target zoom factor.
+
+ @leave May leave with any error code.
+ */
+ virtual void StartContinuousZoomL(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters aContinuousZoomParameters)=0;
+
+ /**
+ Stop any exisiting continuous zoom operation.
+ Since this method is synchronous, no callback shall be issued for the concerned continuous zoom operation.
+ */
+ virtual void StopContinuousZoom()=0;
+
+ /**
+ Retrieves information about the supported settings related to continuous zoom support.
+
+ @param aContinuousZoomInfo
+ The information of supported continuous zoom functionality.
+
+ @leave May leave with any error code.
+ */
+ virtual void GetContinuousZoomSupportInfoL(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo& aContinuousZoomInfo) const=0;
+
+ /**
+ Retrieves the unique id of the continuous zoom object.
+ This is used to identify the continuous zoom handle returned to clients via the MContinuousZoomObserver callback.
+
+ @param aZoomId
+ The unique id of this Continuous Zoom object.
+ */
+ virtual void GetContinuousZoomId(TInt& aZoomId) const=0;
+
+ /**
+ Releases the interface.
+ */
+ virtual void Release()=0;
+ };
+
+#endif // ECAMADVSETTINGSINTF_H