diff -r 000000000000 -r bde4ae8d615e os/mm/imagingandcamerafws/camerafw/Include/ECam/ecamadvsettingsintf.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/imagingandcamerafws/camerafw/Include/ECam/ecamadvsettingsintf.h Fri Jun 15 03:10:57 2012 +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 +#include +#include + +/** 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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