--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imagingandcamerafws/camerafw/source/ecamadvsettings.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,3958 @@
+// 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:
+//
+
+#include <ecam/ecamadvsettingsintf.h>
+#include "ecamversion.h"
+#include <ecam/ecamconstants.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <ecamadvsettingsconst.h>
+#include <ecamadvsettingsdef.h>
+#endif
+#include <ecam/implementationfactoryintf.h>
+const TInt KBaselinedFocusRanges = 0x1F;
+const TInt KBaselinedWhiteBalanceModes = 0x01FF;
+const TUint KBaselinedPixelAspectsMask = (CCamera::CCameraAdvancedSettings::EEPixelAspect59To54 << 1) - 1;
+const TUint KBaselinedFlashModeMask = (CCamera::EFlashManual << 1) - 1;
+const TUint KBaselinedPreCaptureWarning = (CCamera::CCameraAdvancedSettings::EPCWGeneralWarning << 1) - 1;
+const TUint KBaselinedDriveMode = (CCamera::CCameraAdvancedSettings::EDriveModeBurst << 1) - 1;
+
+/**
+Factory function for creating the CCameraPresets object.
+
+@param aCamera
+ a reference to a CCamera object providing the settings.
+
+@return a pointer to a fully constructed CCameraPresets object.
+
+@leave KErrNoMemory Out of memory Or any other system-wide error code.
+
+@note Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.
+*/
+EXPORT_C CCamera::CCameraPresets* CCamera::CCameraPresets::NewL(CCamera& aCamera)
+ {
+ CCamera::CCameraPresets* self = new (ELeave)CCamera::CCameraPresets(aCamera);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+
+ return self;
+ }
+
+/**
+CCameraPresets Constructor.
+
+@param aOwner
+ a reference to a CCamera object providing the settings.
+*/
+EXPORT_C CCamera::CCameraPresets::CCameraPresets(CCamera& aOwner):iOwner(aOwner), iImpl(NULL), iImpl2(NULL)
+ {
+ }
+
+/**
+CCameraPresets second phase constructor.
+
+Function used to initialise internal state of the object. Uses reference to the camera to retrieve
+Camera presets interface pointer.
+
+@leave KErrNoMemory Out of memory.
+*/
+EXPORT_C void CCamera::CCameraPresets::ConstructL()
+ {
+ iImpl = static_cast<MCameraPresets*>(iOwner.CustomInterface(KECamMCameraPresetsUid));
+
+ if (iImpl == NULL)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+ iImpl2 = static_cast<MCameraPresets2*>(iOwner.CustomInterface(KECamMCameraPresets2Uid));
+ }
+
+/**
+Destructor
+*/
+EXPORT_C CCamera::CCameraPresets::~CCameraPresets()
+ {
+ if (iImpl != NULL)
+ {
+ iImpl->Release();
+ }
+ if (iImpl2 != NULL)
+ {
+ iImpl2->Release();
+ }
+ }
+
+/**
+Gets the presets supported by the camera. These are identified by UIDs
+and relate to a known predefined 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 would be populated by the implementation with
+ the specific supported values. If the array is empty on return,
+ the camera does not support presets.
+
+@leave KErrNoMemory Out of memory.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new presets added). So, any extra uid value(unrecognised)
+ passed from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values.
+
+@note Any preset uid, if added in future, has to have a uid value greater than KUidECamPresetFactoryDefaultUidValue
+ otherwise unrecognized preset uids could not be checked.
+*/
+EXPORT_C void CCamera::CCameraPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const
+ {
+ iImpl->GetSupportedPresetsL(aPresets);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new presets added). So, any extra uid value(unrecognised)
+ passed from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ FilterUnrecognisedUids(aPresets, KUidECamPresetFactoryDefaultUidValue);
+ }
+
+/**
+Sets a specific preset supported by the device.
+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.
+*/
+EXPORT_C void CCamera::CCameraPresets::SetPreset(TUid aPreset)
+ {
+ iImpl->SetPreset(aPreset);
+ }
+
+/**
+Gets the current preset set on the camera.
+
+@return The UID of the current preset. If there is no active preset then the
+ returned value is KNullUid.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not
+ prepared to receive extra added uid values (new presets added). So, any extra uid(unrecognised) value received from the
+ implementation will be mapped to KUidECamPresetFactoryDefault at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
+*/
+EXPORT_C TUid CCamera::CCameraPresets::Preset() const
+ {
+ TUid preset = iImpl->Preset();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not
+ prepared to receive extra added uid values (new presets added). So, any extra uid(unrecognised) value received from the
+ implementation will be mapped to KUidECamPresetFactoryDefault at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ if(preset.iUid > KUidECamPresetFactoryDefaultUidValue)
+ {
+ preset = KUidECamPresetFactoryDefault;
+ }
+ }
+
+ return preset;
+ }
+
+/**
+Get all settings affected by the current preset. This is to say that all settings which
+are related to the preset in question will be included in the list, even though the value might
+not have changed.
+
+@param aSettings
+ An empty array of TUids which would be populated by the implementation with
+ the specific settings.
+
+@leave KErrNoMemory Out of memory.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
+*/
+EXPORT_C void CCamera::CCameraPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const
+ {
+ iImpl->GetAffectedSettingsL(aSettings);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ FilterUnrecognisedUids(aSettings, KUidECamEventCameraSettingAutoFocusType2UidValue);
+ }
+
+/**
+Get all settings associated with a specific preset, identified by a UID.
+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 provided preset UID is not recognised.
+@leave KErrNoMemory Out of memory.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
+*/
+EXPORT_C void CCamera::CCameraPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const
+ {
+ iImpl->GetAssociatedSettingsL(aPreset, aSettings);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ FilterUnrecognisedUids(aSettings, KUidECamEventCameraSettingAutoFocusType2UidValue);
+ }
+
+void CCamera::CCameraPresets::FilterUnrecognisedUids(RArray<TUid>& aUids, const TInt aBaselineUid) const
+ {
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ for(TInt index =0; index < aUids.Count(); index++)
+ {
+ /** aBaselineUid is the baseline. Any uid with greater uid value means that it has
+ been added in later versions */
+ if(aUids[index].iUid > aBaselineUid)
+ {
+ aUids.Remove(index);
+ index--;
+ }
+ }
+ }
+ }
+
+/**
+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 ECAM event 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 uids 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 ranges in the usual way.
+ Empty array indicates that there are no range restricted settings for the given preset.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraPresets::GetRangeRestrictedSettingsL(RArray<TUid>& aRangeRestrictedSettings) const
+ {
+ if(iImpl2 != NULL)
+ {
+ iImpl2->GetRangeRestrictedSettingsL(aRangeRestrictedSettings);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 ECAM event KUidECamEventFeatureRestricted. After receiving
+this notification, the client may use this method to retrieve these settings.
+
+@param aFeatureRestrictedSettings
+ An array of uids which represents those settings which have been restricted. These settings are ECam
+ component wide. Empty array indicates that there are no settings which have been been restricted for
+ the given preset.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraPresets::GetFeatureRestrictedSettingsL(RArray<TUid>& aFeatureRestrictedSettings) const
+ {
+ if(iImpl2 != NULL)
+ {
+ iImpl2->GetFeatureRestrictedSettingsL(aFeatureRestrictedSettings);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Retrieves information about whether the preset unlock feature is supported or not. Unlocking the preset helps in making
+further setting changes 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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraPresets::IsPresetUnlockSupportedL(TBool& aUnlockSupported) const
+ {
+ if(iImpl2 != NULL)
+ {
+ iImpl2->IsPresetUnlockSupportedL(aUnlockSupported);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Locks the preset for any further setting changes.
+
+@note Event KUidECamEventPresetLocked is used to notify clients that the preset has been locked.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraPresets::LockPresetL()
+ {
+ if(iImpl2 != NULL)
+ {
+ iImpl2->LockPreset();
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Unlocks the preset to apply further setting changes.
+
+@note Event KUidECamEventPresetUnlocked is used to notify clients that the preset has been unlocked.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraPresets::UnlockPresetL()
+ {
+ if(iImpl2 != NULL)
+ {
+ iImpl2->UnlockPreset();
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Factory function for creating the CCameraAdvancedSettings object.
+
+@param aCamera
+ a reference to a CCamera object providing the settings.
+
+@return a pointer to a fully constructed CCameraAdvancedSettings object.
+
+@leave KErrNoMemory Out of memory or any other system-wide error code.
+
+@note Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings* CCamera::CCameraAdvancedSettings::NewL(CCamera& aCamera)
+ {
+ CCamera::CCameraAdvancedSettings* self = new (ELeave)CCamera::CCameraAdvancedSettings(aCamera);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+
+ return self;
+ }
+
+/**
+CCameraAdvancedSettings Constructor.
+
+@param aOwner
+ a reference to a CCamera object providing the settings.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::CCameraAdvancedSettings(CCamera& aOwner) : iOwner(aOwner), iImpl(NULL), iImpl2(NULL), iImpl3(NULL), iImpl4(NULL)
+ {
+ }
+
+/**
+CCameraAdvancedSettings second phase constructor.
+
+Function used to initialise internal state of the object. Uses reference to the camera to retrieve
+Camera advanced settings interface pointer.
+
+@leave KErrNoMemory Out of memory.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::ConstructL()
+ {
+ iImpl = static_cast<MCameraAdvancedSettings*>(iOwner.CustomInterface(KECamMCameraAdvancedSettingsUid));
+ if (iImpl == NULL)
+ {
+ User::Leave(KErrNotSupported);
+ }
+ iImpl2 = static_cast<MCameraAdvancedSettings2*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings2Uid));
+ iImpl3 = static_cast<MCameraAdvancedSettings3*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings3Uid));
+ iImpl4 = static_cast<MCameraAdvancedSettings4*>(iOwner.CustomInterface(KECamMCameraAdvancedSettings4Uid));
+ }
+
+/**
+Destructor
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::~CCameraAdvancedSettings()
+ {
+ if (iImpl != NULL)
+ {
+ iImpl->Release();
+ }
+ if (iImpl2 != NULL)
+ {
+ iImpl2->Release();
+ }
+ if (iImpl3 != NULL)
+ {
+ iImpl3->Release();
+ }
+ if (iImpl4 != NULL)
+ {
+ iImpl4->Release();
+ }
+ }
+
+/**
+Gets the type of this camera.
+@see TCameraType
+
+@return the type of this camera
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TCameraType CCamera::CCameraAdvancedSettings::CameraType() const
+ {
+ return iImpl->CameraType();
+ }
+
+/**
+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.
+@see TCameraType
+
+@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.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TCameraType CCamera::CCameraAdvancedSettings::CameraType(TInt aCameraIndex)
+ {
+ return iImpl->CameraType(aCameraIndex);
+ }
+
+/**
+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.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsCameraPresent() const
+ {
+ return iImpl->IsCameraPresent();
+ }
+
+/**
+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.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsCameraPresent(TInt aCameraIndex)
+ {
+ return iImpl->IsCameraPresent(aCameraIndex);
+ }
+
+/**
+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].
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::CameraIndex() const
+ {
+ return iImpl->CameraIndex();
+ }
+
+/**
+Gets all of the supported stabilization modes on the camera. The result is a bitfield
+of the valid TStabilizationMode flags.
+@see TStabilizationMode
+
+@return a bitfield of all supported stabilization modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationModes() const
+ {
+ return iImpl->SupportedStabilizationModes();
+ }
+
+/**
+Gets current stabilization mode on the camera.
+The result is a valid TStabilizationMode value.
+
+@return current stabilization mode of type TStabilizationMode.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationMode CCamera::CCameraAdvancedSettings::StabilizationMode() const
+ {
+ return iImpl->StabilizationMode();
+ }
+
+/**
+Sets a specific stabilization mode on the camera.
+
+Stabilization mode change fires a KUidECamEventCameraSettingStabilizationMode
+event to all MCameraObserver2 clients of this specific camera.
+
+@param aStabilizationMode
+ new stabilization mode of TStabilizationMode type.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)
+ {
+ iImpl->SetStabilizationMode(aStabilizationMode);
+ }
+
+/**
+Gets all of the supported focus modes on the camera. The result is a bitfield
+of the valid TFocusMode flags.
+@see TFocusMode
+
+@return a bitfield of all supported focus modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFocusModes() const
+ {
+ return iImpl->SupportedFocusModes();
+ }
+
+/**
+Gets current focus mode on the camera.
+The result is a valid TFocusMode value.
+
+@return current focus mode.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TFocusMode CCamera::CCameraAdvancedSettings::FocusMode() const
+ {
+ return iImpl->FocusMode();
+ }
+
+/**
+Sets a specific focus mode on the camera.
+Focus mode change fires a KUidECamEventCameraSettingFocusMode event
+to all MCameraObserver2 clients of the camera.
+
+@param aFocusMode
+ new focus mode of TFocusMode type.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)
+ {
+ iImpl->SetFocusMode(aFocusMode);
+ }
+
+/**
+Gets all supported focus ranges on the camera.
+
+@return an integer - a bitfield of all supported TFocusRange values.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFocusRanges() const
+ {
+ TInt supportedFocusRanges = iImpl->SupportedFocusRanges();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ supportedFocusRanges &= KBaselinedFocusRanges;
+ }
+
+ return supportedFocusRanges;
+ }
+
+/**
+Gets current focus range on the camera.
+
+@return the current TFocusRange value.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value received
+ from the implementation will be dropped and EFocusRangeAuto would be passed instead.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TFocusRange CCamera::CCameraAdvancedSettings::FocusRange() const
+ {
+ CCamera::CCameraAdvancedSettings::TFocusRange focusRange = iImpl->FocusRange();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value received
+ from the implementation will be dropped and EFocusRangeAuto would be passed instead.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ if(static_cast<TInt>(focusRange) > KBaselinedFocusRanges)
+ {
+ focusRange = CCamera::CCameraAdvancedSettings::EFocusRangeAuto;
+ }
+ }
+
+ return focusRange;
+ }
+
+/**
+Sets a specific focus range on the camera.
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)
+ {
+ iImpl->SetFocusRange(aFocusRange);
+ }
+
+/**
+Gets all supported auto focus types on the camera.
+
+@return an integer - a bitfield of all supported TAutoFocusType values.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedAutoFocusTypes() const
+ {
+ return iImpl->SupportedAutoFocusTypes();
+ }
+
+/**
+Gets current auto focus type on the camera.
+@see TAutoFocusType
+
+@return a CCamera::TAutoFocusType value.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TAutoFocusType CCamera::CCameraAdvancedSettings::AutoFocusType() const
+ {
+ return iImpl->AutoFocusType();
+ }
+
+/**
+Sets a specific auto focus type on the camera.
+The focus type change fires both, KUidECamEventCameraSettingAutoFocusType and
+KUidECamEventCameraSettingAutoFocusType2 event to all MCameraObserver2 clients of the camera.
+@see KUidECamEventCameraSettingAutoFocusType
+
+@param aAutoFocusType
+ Autofocus selection.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)
+ {
+ iImpl->SetAutoFocusType(aAutoFocusType);
+ }
+
+/**
+Gets all supported auto focus areas on the camera.
+
+@return an integer - a bitfield of al supported TAutoFocusArea values.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedAutoFocusAreas() const
+ {
+ return iImpl->SupportedAutoFocusAreas();
+ }
+
+/**
+Gets current chosen auto focus area on the camera.
+
+@return a CCamera::TAutoFocusArea value.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TAutoFocusArea CCamera::CCameraAdvancedSettings::AutoFocusArea() const
+ {
+ return iImpl->AutoFocusArea();
+ }
+
+/**
+Sets a specific auto focus area on the camera.
+Focus area change fires a KUidECamEventCameraSettingAutoFocusArea event
+to all MCameraObserver2 clients of the camera.
+
+@param aAutoFocusArea
+ Autofocus area selection.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)
+ {
+ iImpl->SetAutoFocusArea(aAutoFocusArea);
+ }
+
+/**
+Get focus distance in millimetres.
+
+@return the current focus distance in millimetres, directly from user setting of lenses.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::FocusDistance() const
+ {
+ return iImpl->FocusDistance();
+ }
+
+/**
+Set focus distance in millimetres. Focus distance change fires a KUidECamEventCameraSettingFocusDistance event
+to all MCameraObserver2 clients of the camera.
+
+@param aDistance
+ the new distance value in millimetres.
+
+@note KUidECamEvent2CameraSettingFocusDistance may be used to provide the focussing feedback as well. This means that
+ the feedback will state whether the proper focussing has been achieved after setting the given focus distance.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetFocusDistance(TInt aDistance)
+ {
+ iImpl->SetFocusDistance(aDistance);
+ }
+
+/**
+Get minimum focus distance in millimetres
+
+@return the minimum (35 camera equivalent) focal length of a camera.
+@note Current Focal length is calculated as focalLength = opticalZoom * minFocalLength;
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetMinFocalLength() const
+ {
+ return iImpl->GetMinFocalLength();
+ }
+
+/**
+Gets the set of camera supported ISO rates.
+
+@param aSupportedIsoRates
+ an array of integers which gets filled 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 permanently set value. If this value is not known, empty array may be
+ returned; corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const
+ {
+ iImpl->GetSupportedIsoRatesL(aSupportedIsoRates);
+ }
+
+/**
+Gets current ISO rate.
+
+@return current ISO rate as a TInt value.
+ Negative value returned means error case (system wide error code) and positive value means current ISO rate.
+
+@note The returned value may be checked with the list of supported ISO rates. If value returned does not belong to
+ this list, then it may be treated as an error case.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::IsoRate() const
+ {
+ return iImpl->IsoRate();
+ }
+
+/**
+Set current ISO rate for the camera.
+Triggers KUidECamEventCameraSettingIsoRate to all MCameraObserver2 clients of the camera.
+
+@param aRate
+ required new ISO rate.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetIsoRate(TInt aRate)
+ {
+ iImpl->SetIsoRate(aRate);
+ }
+
+/**
+Gets the current discrete aperture steps (F-stops) supported by the camera.
+
+@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 may be
+ returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const
+ {
+ iImpl->GetAperturesL(aFStops, aInfo);
+ }
+
+/**
+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.
+ Negative value returned means error case (system wide error code) and positive value means current aperture.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::Aperture() const
+ {
+ return iImpl->Aperture();
+ }
+
+/**
+Set a new aperture value.
+All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingAperture
+event notification when aperture value is changed.
+
+@param aFStop
+ a new aperture value in the supported by the camera range.
+
+@note The aperture parameter value is an integer, multiplied by KECamFineResolutionFactor.
+ For example to set an aperture of F2.8, call SetAperture(280).
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetAperture(TInt aFStop)
+ {
+ iImpl->SetAperture(aFStop);
+ }
+
+/**
+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 camera.
+
+@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 may be
+ returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const
+ {
+ iImpl->GetShutterSpeedsL(aShutterSpeeds, aInfo);
+ }
+
+/**
+Gets the current shutter speed
+
+@return the current shutter speed in microseconds.
+ Negative value returned means error case (system wide error code) and positive value means current shutter speed.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::ShutterSpeed() const
+ {
+ return iImpl->ShutterSpeed();
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetShutterSpeed(TInt aShutterSpeed)
+ {
+ iImpl->SetShutterSpeed(aShutterSpeed);
+ }
+
+/**
+Get all supported metering modes on this camera represented as bitfield of type TMeteringMode.
+
+@return the set of supported metering modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedMeteringModes() const
+ {
+ return iImpl->SupportedMeteringModes();
+ }
+
+/**
+Get current metering mode.
+
+@return a value of type TMeteringMode.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TMeteringMode CCamera::CCameraAdvancedSettings::MeteringMode() const
+ {
+ return iImpl->MeteringMode();
+ }
+
+/**
+Set the current metering mode. When set, all MCameraObserver2 clients are notified
+with a KUidECamEventCameraSettingMeteringMode event.
+
+@param aMeteringMode
+ new selection for metering mode of type TMeteringMode.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)
+ {
+ iImpl->SetMeteringMode(aMeteringMode);
+ }
+
+/**
+Get all supported drive modes as bitfields of TDriveMode type.
+
+@return the set of supported drive modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedDriveModes() const
+ {
+ TInt supportedDriveModes = iImpl->SupportedDriveModes();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ supportedDriveModes &= KBaselinedDriveMode;
+ }
+
+ return supportedDriveModes;
+ }
+
+/**
+Gets currently active drive mode.
+
+@return current drive mode.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TDriveMode CCamera::CCameraAdvancedSettings::DriveMode() const
+ {
+ CCamera::CCameraAdvancedSettings::TDriveMode driveMode = iImpl->DriveMode();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value received
+ from the implementation will be dropped and EDriveModeAuto would be passed instead.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ if(static_cast<TUint>(driveMode) > KBaselinedDriveMode)
+ {
+ driveMode = CCamera::CCameraAdvancedSettings::EDriveModeAuto;
+ }
+ }
+
+ return driveMode;
+ }
+
+/**
+Set the current metering mode. When set all MCameraObserver2 clients are notified with
+KUidECamEventCameraSettingDriveMode.
+
+@param aDriveMode
+ new selection for drive mode value of type TDriveMode.
+
+@note Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or StartPerformantVideoCaptureL())
+ if an image/video capture is still outstanding, this method may report error KErrInUse.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)
+ {
+ iImpl->SetDriveMode(aDriveMode);
+ }
+
+/**
+Get all supported bracket modes as bitfields.
+
+@return the set of all supported bracket modes as an integer.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketModes() const
+ {
+ return iImpl->SupportedBracketModes();
+ }
+
+/**
+Get current bracket mode.
+
+@return the current bracket mode TBracketMode.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TBracketMode CCamera::CCameraAdvancedSettings::BracketMode() const
+ {
+ return iImpl->BracketMode();
+ }
+
+/**
+Set new bracket mode. All MCameraObserver2 clients are notified with
+KUidECamEventCameraSettingBracketMode.
+
+@param aBracketMode
+ new selection for bracket mode of type TBracketMode.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)
+ {
+ iImpl->SetBracketMode(aBracketMode);
+ }
+
+/**
+Get all supported bracket parameters as bitfields.
+
+@return the set of all currently supported bracket modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketParameters() const
+ {
+ return iImpl->SupportedBracketParameters();
+ }
+
+/**
+Get current bracket parameter.
+
+@return the current bracket mode TBracketParameter.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TBracketParameter CCamera::CCameraAdvancedSettings::BracketParameter() const
+ {
+ return iImpl->BracketParameter();
+ }
+
+/**
+Set new bracket parameter
+When set all clients are notified with
+KUidECamEventCameraSettingBracketParameter.
+
+@param aBracketParameter
+ new selection for parameter type of type TBracketParameter.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)
+ {
+ iImpl->SetBracketParameter(aBracketParameter);
+ }
+
+/**
+Get all supported bracket steps as bitfields.
+
+@return the set of all supported bracket modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedBracketSteps() const
+ {
+ return iImpl->SupportedBracketSteps();
+ }
+
+/**
+Get current bracket step.
+
+@return the current bracket mode TBracketStep.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TBracketStep CCamera::CCameraAdvancedSettings::BracketStep() const
+ {
+ return iImpl->BracketStep();
+ }
+
+/**
+Set new bracket step. All MCameraObserver2 clients are notified with
+KUidECamEventCameraSettingBracketStep.
+
+@param aBracketStep
+ new selection for step of type TBracketStep.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)
+ {
+ iImpl->SetBracketStep(aBracketStep);
+ }
+
+/**
+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 operation.
+
+@param aStartIndex
+ the index of the start frame, starts from 0.
+
+@param aFrames
+ the number of frames to be merged.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const
+ {
+ iImpl->GetBracketMerge(aStartIndex, aFrames);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetBracketMerge(TInt aStartIndex, TInt aFrames)
+ {
+ iImpl->SetBracketMerge(aStartIndex, aFrames);
+ }
+
+/**
+Get camera all supported flash modes CCamera::TFlash
+
+@return the set of all supported flash modes as bitfields in an integer.
+@note Some of the flash modes are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()
+@see CCamera::TFlash
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedFlashModes() const
+ {
+ TInt modes = iImpl->SupportedFlashModes();
+ if (iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ modes &= KBaselinedFlashModeMask;
+ }
+ return modes;
+ }
+
+/**
+Gets the currently set flash mode.
+
+@return The currently set flash mode.
+@note Clients not using the CCamera::New2L() or CCamera::NewDuplicate2L() would be given CCamera::EFlashAuto
+ if current flash mode exceeds CCamera::EFlashManual
+@see CCamera::TFlash
+*/
+EXPORT_C CCamera::TFlash CCamera::CCameraAdvancedSettings::FlashMode() const
+ {
+ TInt mode = iImpl->FlashMode();
+ if (iOwner.CameraVersion() == KCameraDefaultVersion && mode > KBaselinedFlashModeMask)
+ {
+ mode = EFlashAuto;
+ }
+ return static_cast<CCamera::TFlash>(mode);
+ }
+
+/**
+Sets the flash mode.
+
+Triggers a KUidECamEventCameraSettingFlashMode event to all camera
+MCameraObserver2 clients.
+
+@param aMode
+ The required flash mode.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetFlashMode(CCamera::TFlash aMode)
+ {
+ iImpl->SetFlashMode(aMode);
+ }
+
+/**
+Gets whether the flash red eye reduction is switched on.
+
+@return The present state - ETrue for switched on and EFalse for switched off.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::RedEyeReduceOn() const
+ {
+ return iImpl->RedEyeReduceOn();
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetRedEyeReduceOn(TBool aState)
+ {
+ iImpl->SetRedEyeReduceOn(aState);
+ }
+
+/**
+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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+
+@note 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 may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const
+ {
+ iImpl->GetFlashCompensationStepsL(aFlashCompensationSteps, aInfo);
+ }
+
+/**
+@deprecated Use TInt GetFlashCompensationStep(TInt& aFlashCompensationStep);
+
+Get current flash power compensation step.
+
+@return current flash compensation step.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::FlashCompensationStep() const
+ {
+ return iImpl->FlashCompensationStep();
+ }
+
+/**
+Get current flash power compensation step.
+
+@param aFlashCompensationStep
+ Reference to the current flash compensation step.
+
+@return system wide error code.
+
+@note Use this method in place of deprecated TInt FlashCompensationStep()
+
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetFlashCompensationStep(TInt& aFlashCompensationStep) const
+ {
+ return iImpl->GetFlashCompensationStep(aFlashCompensationStep);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetFlashCompensationStep(TInt aFlashCompensationStep)
+ {
+ iImpl->SetFlashCompensationStep(aFlashCompensationStep);
+ }
+
+/**
+Get current flash power compensation range measured in a already selected compensation step magnitude.
+@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 multiplier (in steps) and the direction (the sign). Steps are always assumed integers.
+
+@param aNegativeCompensation
+ a reference to an integer returning the maximum number of steps available for negative compensation.
+
+@param aPositiveCompensation
+ a reference to an integer returning the maximum number of steps available for positive compensation.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
+ {
+ iImpl->GetFlashCompensationRangeInSteps(aNegativeCompensation, aPositiveCompensation);
+ }
+
+/**
+@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 of compensation steps as an integer.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::FlashCompensation() const
+ {
+ return iImpl->FlashCompensation();
+ }
+
+/**
+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.
+
+@note Use this method in place of deprecated TInt FlashCompensation()
+
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetFlashCompensation(TInt& aFlashCompensation) const
+ {
+ return iImpl->GetFlashCompensation(aFlashCompensation);
+ }
+
+/**
+Set the current flash compensation value as integer steps.
+Positive values increase power, negative reduce power. The change is not acumulative e.g. 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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetFlashCompensation(TInt aFlashCompensationSteps)
+ {
+ iImpl->SetFlashCompensation(aFlashCompensationSteps);
+ }
+
+/**
+Check whether there is an external flash source.
+
+@return ETrue if an external flash source is present, EFalse otherwise
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::IsExternalFlashPresent() const
+ {
+ return iImpl->IsExternalFlashPresent();
+ }
+
+/**
+Gets the current discrete manual flash power levels supported by the camera 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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+ 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 permanently set value. If this value is not known, empty
+ array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const
+ {
+ return iImpl->GetManualFlashPowerLevelsL(aManualFlashPowerLevels, aInfo);
+ }
+
+/**
+Gets the current manual flash power level on the camera.
+
+@return the current manual flash power level as a value in the range [0:100].
+ Negative value returned means error case (system wide error code) and positive value means current manual flash power level.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::ManualFlashPowerLevel() const
+ {
+ return iImpl->ManualFlashPowerLevel();
+ }
+
+/**
+Sets the current manual flash power level on the camera.
+Triggers a KUidECamEventCameraSettingFlashManualPower event to all MCameraObserver2 clients.
+
+@param aManualFlashPowerLevel
+ one of the values returned in GetManualFlashPowerLevelsL().
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetManualFlashPowerLevel(TInt aManualFlashPowerLevel)
+ {
+ iImpl->SetManualFlashPowerLevel(aManualFlashPowerLevel);
+ }
+
+/**
+Get Supported exposure modes - bitfields of CCamera::TExposure
+
+@return the set of supported exposure modes.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedExposureModes() const
+ {
+ return iImpl->SupportedExposureModes();
+ }
+
+/**
+Gets the currently set exposure setting value.
+
+@return The currently set exposure setting value.
+*/
+EXPORT_C CCamera::TExposure CCamera::CCameraAdvancedSettings::ExposureMode() const
+ {
+ return iImpl->ExposureMode();
+ }
+
+/**
+Sets the exposure mode of the camera.
+Triggers a KUidECamEventCameraSettingExposureMode event to all MCameraObserver2 clients.
+
+@param aExposureMode
+ The required exposure adjustment.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureMode(CCamera::TExposure aExposureMode)
+ {
+ iImpl->SetExposureMode(aExposureMode);
+ }
+
+/**
+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.
+
+@note When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+ When camera device is incapable of revealing the exposure compensation steps supported,
+ it has to be assumed that camera will work only on the permanently set value. If this value is not known, empty
+ array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const
+ {
+ iImpl->GetExposureCompensationStepsL(aExposureCompensationSteps, aInfo);
+ }
+
+/**
+@deprecated Use TInt GetExposureCompensationStep(TInt& aExposureCompensationStep);
+
+Get current exposure compensation step.
+
+@return the current exposure compensation step.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::ExposureCompensationStep() const
+ {
+ return iImpl->ExposureCompensationStep();
+ }
+
+/**
+Get current exposure compensation step.
+
+@param aExposureCompensationStep
+ Reference to the current exposure compensation step.
+
+@return system wide error code.
+
+@note Use this method in place of deprecated TInt ExposureCompensationStep()
+
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetExposureCompensationStep(TInt& aExposureCompensationStep) const
+ {
+ return iImpl->GetExposureCompensationStep(aExposureCompensationStep);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureCompensationStep(TInt aExposureCompensationStep)
+ {
+ iImpl->SetExposureCompensationStep(aExposureCompensationStep);
+ }
+
+/**
+Get current exposure compensation range in steps. It depends on the previously
+selected exposure compensation step.
+
+@see GetFlashCompensationRangeInSteps()
+
+@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,
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
+ {
+ iImpl->GetExposureCompensationRangeInSteps(aNegativeCompensation, aPositiveCompensation);
+ }
+
+/**
+@deprecated Use TInt GetExposureCompensation(TInt& aExposureCompensation);
+
+Get the current exposure compensation 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 of compensation steps as an integer.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::ExposureCompensation() const
+ {
+ return iImpl->ExposureCompensation();
+ }
+
+/**
+Get the current exposure compensation 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.
+
+@note Use this method in place of deprecated TInt ExposureCompensation()
+
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::GetExposureCompensation(TInt& aExposureCompensation) const
+ {
+ return iImpl->GetExposureCompensation(aExposureCompensation);
+ }
+
+/**
+Set the current exposure compensation value as integer steps.
+Triggers a KUidECamEventCameraSettingExposureCompensation event to all MCameraObserver2 clients.
+
+@param aExposureCompensationSteps
+ a required number of compensation steps - negative value reduce the exposure time
+ positive increases the exposure time.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureCompensation(TInt aExposureCompensationSteps)
+ {
+ iImpl->SetExposureCompensation(aExposureCompensationSteps);
+ }
+
+/**
+Gets camera supported set of white balance adjustments.
+
+@return bitfield of all supported CCamera::TWhiteBalance values.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedWhiteBalanceModes() const
+ {
+ TInt supportedWhiteBalanceModes = iImpl->SupportedWhiteBalanceModes();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ supportedWhiteBalanceModes &= KBaselinedWhiteBalanceModes;
+ }
+
+ return supportedWhiteBalanceModes;
+ }
+
+/**
+Gets the current white balance value.
+
+@return The current white balance value.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) received
+ from the implementation will be dropped and EWBAuto would be passed instead.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
+*/
+EXPORT_C CCamera::TWhiteBalance CCamera::CCameraAdvancedSettings::WhiteBalanceMode() const
+ {
+ CCamera::TWhiteBalance whiteBalance = iImpl->WhiteBalanceMode();
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) received
+ from the implementation will be dropped and EWBAuto would be passed instead.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ if(static_cast<TInt>(whiteBalance) > KBaselinedWhiteBalanceModes)
+ {
+ whiteBalance = CCamera::EWBAuto;
+ }
+ }
+
+ return whiteBalance;
+ }
+
+/**
+Sets the white balance adjustment of the camera.
+
+No effect if this is not supported, see TCameraInfo::iWhiteBalanceModesSupported.
+Triggers KUidECamEventCameraSettingWhiteBalanceMode event to all MCameraObserver2 clients.
+
+@param aWhiteBalanceMode
+ The required white balance mode.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)
+ {
+ iImpl->SetWhiteBalanceMode(aWhiteBalanceMode);
+ }
+
+/**
+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.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::ApertureExposureLockOn() const
+ {
+ return iImpl->ApertureExposureLockOn();
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetApertureExposureLockOn(TBool aAELock)
+ {
+ iImpl->SetApertureExposureLockOn(aAELock);
+ }
+
+/**
+Gets the current state for button clicking sound effect.
+
+@return ETrue to switch clicking sound on, EFalse sound off
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::ShootClickOn() const
+ {
+ return iImpl->ShootClickOn();
+ }
+
+/**
+Sets the button clicking sound on /off. Triggers a KUidECamEventSoundClick event
+to all MCameraObserver2 clients.
+
+@param aShootClickOn
+ ETrue to switch clicking sound on, EFalse sound is switched off.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetShootClickOn(TBool aShootClickOn)
+ {
+ iImpl->SetShootClickOn(aShootClickOn);
+ }
+
+/**
+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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const
+ {
+ iImpl->GetTimerIntervalsL(aTimerIntervals, aInfo);
+ }
+
+/**
+Get current timer value. Active only when drive mode is EDriveModeTimed.
+Timer resolution is in microseconds.
+
+@return current time interval value.
+ Negative value returned means error case (system wide error code) and positive value means current timer interval.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::TimerInterval() const
+ {
+ return iImpl->TimerInterval();
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetTimerInterval(TInt aTimerInterval)
+ {
+ iImpl->SetTimerInterval(aTimerInterval);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const
+ {
+ iImpl->GetTimeLapsePeriodRange(aTimeLapseMin, aTimeLapseMax);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const
+ {
+ iImpl->GetTimeLapse(aStart, aEnd, aInterval);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval)
+ {
+ iImpl->SetTimeLapse(aStart, aEnd, aInterval);
+ }
+
+/**
+Get current picture orientation
+
+@return a TPictureOrientation value.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TPictureOrientation CCamera::CCameraAdvancedSettings::PictureOrientation() const
+ {
+ return iImpl->PictureOrientation();
+ }
+
+/**
+Set a new picture orientation
+This triggers a KUidECamEventCameraSettingPictureOrientation event to all MCameraObserver2 clients.
+
+@param aOrientation
+ a value of TPictureOrientation denoting the new orientation.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)
+ {
+ iImpl->SetPictureOrientation(aOrientation);
+ }
+
+/**
+Get supported pixel aspect ratio.
+
+@return a bitfield of all supported TPixelAspectRatio values.
+@note Some of the pixel aspect ratios are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedPixelAspectRatios() const
+ {
+ TInt supportedRatios = iImpl->SupportedPixelAspectRatios();
+ /**
+ Mask out new features for old clients
+ */
+ if (iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ supportedRatios &= KBaselinedPixelAspectsMask;
+ }
+ return supportedRatios;
+ }
+
+/**
+Get current pixel aspect ratio.
+
+@return a TPixelAspectRatio value.
+@note Some of the pixel aspect ratios are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TPixelAspectRatio CCamera::CCameraAdvancedSettings::PixelAspectRatio() const
+ {
+ TInt ratio = iImpl->PixelAspectRatio();
+ /**
+ Mask out new features for old clients
+ */
+ if (iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ ratio &= KBaselinedPixelAspectsMask;
+ }
+ return static_cast<CCamera::CCameraAdvancedSettings::TPixelAspectRatio>( ratio );
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)
+ {
+ iImpl->SetPixelAspectRatio(aPixelAspectRatio);
+ }
+
+/**
+Get supported YUV ranges.
+
+@return a bitfileld of all supported TYuvRange values.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedYuvRanges() const
+ {
+ return iImpl->SupportedYuvRanges();
+ }
+
+/**
+Get current YUV range.
+
+@return a TYuvRange value.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TYuvRange CCamera::CCameraAdvancedSettings::YuvRange() const
+ {
+ return iImpl->YuvRange();
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)
+ {
+ iImpl->SetYuvRange(aYuvRange);
+ }
+
+/**
+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.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::BurstImages() const
+ {
+ return iImpl->BurstImages();
+ }
+
+/**
+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 StartPerformantVideoCaptureL())
+ if an image/video capture is still outstanding, this method may report error KErrInUse.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetBurstImages(TInt aImages)
+ {
+ iImpl->SetBurstImages(aImages);
+ }
+
+/**
+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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+
+@leave KErrNoMemory Out of memory.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const
+ {
+ iImpl->GetOpticalZoomStepsL(aOpticalZoomSteps, aInfo);
+ }
+
+/**
+Gets the currently set zoom value.
+
+@return The currently set optical zoom value. The value is multiplied by
+ KECamFineResolutionFactor to retain precision.
+ Negative value returned means error case (system wide error code) and positive value means current optical zoom.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::OpticalZoom() const
+ {
+ return iImpl->OpticalZoom();
+ }
+
+/**
+Sets the zoom using a specific value. Triggers a KUidECamEventCameraSettingOpticalZoom
+event to all MCameraObserver2 clients.
+
+@param aOpticalZoom
+ Required zoom value.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetOpticalZoom(TInt aOpticalZoom)
+ {
+ iImpl->SetOpticalZoom(aOpticalZoom);
+ }
+
+/**
+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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+
+@leave KErrNoMemory Out of memory.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo) const
+ {
+ iImpl->GetDigitalZoomStepsL(aDigitalZoomSteps, aInfo);
+ }
+
+/**
+Gets the currently set digital zoom value.
+
+@return The currently set digital zoom value. The value is multiplied by
+ KECamFineResolutionFactor to retain precision.
+ Negative value returned means error case (system wide error code) and positive value means current digital zoom.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::DigitalZoom() const
+ {
+ return iImpl->DigitalZoom();
+ }
+
+/**
+Sets the digital zoom value. Triggers a KUidECamEventCameraSettingDigitalZoom event
+to all MCameraObserver2 clients.
+
+@param aDigitalZoom
+ Required zoom value.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetDigitalZoom(TInt aDigitalZoom)
+ {
+ iImpl->SetDigitalZoom(aDigitalZoom);
+ }
+
+/**
+Checks whether exposure value is locked or not.
+
+@return whether exposure value is locked or not.
+ ETrue if locked, EFalse otherwise.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::ExposureLockOn() const
+ {
+ return iImpl->ExposureLockOn();
+ }
+
+/**
+Sets exposure lock state. Triggers a KUidECamEventCameraSettingExposureLock event
+ to all MCameraObserver2 clients.
+
+@param aState
+ Required new state.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetExposureLockOn(TBool aState)
+ {
+ iImpl->SetExposureLockOn(aState);
+ }
+
+/**
+Checks whether AutoFocus value is locked or not.
+
+@return whether AutoFocus value is locked or not.
+ ETrue if locked, EFalse otherwise.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::AutoFocusLockOn() const
+ {
+ return iImpl->AutoFocusLockOn();
+ }
+
+/**
+Sets autofocus lock state. Triggers a KUidECamEventCameraSettingAutoFocusLock event
+to all MCameraObserver2 clients.
+
+@param aState
+ Required new state.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutoFocusLockOn(TBool aState)
+ {
+ iImpl->SetAutoFocusLockOn(aState);
+ }
+
+/**
+Gets an array of all the advanced settings parameters supported by the camera.
+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.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const
+ {
+ iImpl->GetSupportedSettingsL(aSettings);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ for(TInt index =0; index < aSettings.Count(); index++)
+ {
+ /** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has
+ been added in later versions */
+ if(aSettings[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)
+ {
+ aSettings.Remove(index);
+ index--;
+ }
+ }
+ }
+ }
+
+/**
+Gets an array of all the advanced settings parameters currently active on the camera.
+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.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const
+ {
+ iImpl->GetActiveSettingsL(aActiveSettings);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ for(TInt index =0; index < aActiveSettings.Count(); index++)
+ {
+ /** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has
+ been added in later versions */
+ if(aActiveSettings[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)
+ {
+ aActiveSettings.Remove(index);
+ index--;
+ }
+ }
+ }
+ }
+
+/**
+Gets an array of all the advanced settings parameters currently disabled on the camera.
+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.
+
+@note if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const
+ {
+ iImpl->GetDisabledSettingsL(aDisabledSettings);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
+ from the implementation will be filtered at this point.
+ To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ for(TInt index =0; index < aDisabledSettings.Count(); index++)
+ {
+ /** KUidECamEventCameraSettingAutoFocusType2UidValue is the baseline. Any settings with greater uid value means that it has
+ been added in later versions */
+ if(aDisabledSettings[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)
+ {
+ aDisabledSettings.Remove(index);
+ index--;
+ }
+ }
+ }
+ }
+
+/**
+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.
+*/
+EXPORT_C TBool CCamera::CCameraAdvancedSettings::AutomaticSizeSelectionChangeOn() const
+ {
+ return iImpl->AutomaticSizeSelectionChangeOn();
+ }
+
+/**
+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
+ */
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetAutomaticSizeSelectionChangeOn(TBool aSetOn)
+ {
+ iImpl->SetAutomaticSizeSelectionChangeOn(aSetOn);
+ }
+
+/**
+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.
+
+@note When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const
+ {
+ iImpl->GetSupportedContinuousAutoFocusTimeoutsL(aTimeouts, aInfo);
+ }
+
+/**
+Gets the current value for continuous autofocus timeout. Timeouts are in microseconds.
+
+@return the timeout value in microseconds.
+ Negative value returned means error case (system wide error code) and positive value means current value for
+ continuous autofocus timeout.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::ContinuousAutoFocusTimeout() const
+ {
+ return iImpl->ContinuousAutoFocusTimeout();
+ }
+
+/**
+Sets the current 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
+ the timeout value in microseconds.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetContinuousAutoFocusTimeout(TInt aTimeout)
+ {
+ iImpl->SetContinuousAutoFocusTimeout(aTimeout);
+ }
+
+/**
+Gets all supported stabilization effects on the camera.
+
+@return an integer - a bitfield of all supported TStabilizationEffect values.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationEffect CCamera::CCameraAdvancedSettings::StabilizationEffect() const
+ {
+ return iImpl->StabilizationEffect();
+ }
+
+/**
+Gets the current stabilization effect on the camera.
+
+@return a TStabilizationEffect value.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationEffects() const
+ {
+ return iImpl->SupportedStabilizationEffects();
+ }
+
+/**
+Sets a specific stabilization effect on the camera.
+When a value is set, MCameraObserver2 clients for that camera will receive a
+KUidECamEventCameraSettingsStabilizationEffect event notification.
+
+@param aEffect
+ stabilization effect selection of type TStabilizationEffect.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)
+ {
+ iImpl->SetStabilizationEffect(aEffect);
+ }
+
+/**
+Gets all supported stabilization algorithm values on the camera.
+
+@return an integer - a bitfield of all supported TStabilizationAlgorithmComplexity values.
+*/
+
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::SupportedStabilizationComplexityValues() const
+ {
+ return iImpl->SupportedStabilizationComplexityValues();
+ }
+
+/**
+Gets current active stabilization algorithm selection on the camera.
+
+@return a TStabilizationAlgorithmComplexity value.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity CCamera::CCameraAdvancedSettings::StabilizationComplexity() const
+ {
+ return iImpl->StabilizationComplexity();
+ }
+
+/**
+Sets a specific stabilization algorithm on the camera.
+When a value is set, MCameraObserver2 clients for that camera will receive a
+KUidECamEventSettingsStabilizationAlgorithmComplexity event notification.
+
+@param aComplexity
+ stabilization effect selection of type TStabilizationAlgorithmComplexity.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)
+ {
+ iImpl->SetStabilizationComplexity(aComplexity);
+ }
+
+/**
+Gets the units in which the white balance is measured on the camera.
+@note The methods used to get or set these differ depending on the supported unit type.
+It is expected that a camera will support only a single type or none.
+
+@return a value of TWBUnits type.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TWBUnits CCamera::CCameraAdvancedSettings::SupportedWBUnits() const
+ {
+ return iImpl->SupportedWBUnits();
+ }
+
+/**
+Get white balance value represented as a RGB triplet.
+
+@see TRgb
+
+@param aValue
+ a reference to TRgb object which will contain the current white balance.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetWBRgbValue(TRgb& aValue) const
+ {
+ iImpl->GetWBRgbValue(aValue);
+ }
+
+/**
+Set white balance value using a RGB triplet.
+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.
+
+@see TRgb
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetWBRgbValue(const TRgb& aValue)
+ {
+ iImpl->SetWBRgbValue(aValue);
+ }
+
+/**
+Get the white balance values, as temperature measured in Kelvin, supported on the camera.
+
+@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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const
+ {
+ iImpl->GetWBSupportedColorTemperaturesL(aWBColorTemperatures, aInfo);
+ }
+
+/**
+Get the white balance as a temperature in Kelvin
+
+@return current white balance value as a temperature in Kelvins.
+ Negative value returned means error case (system wide error code) and positive value means current value for
+ white balance as a temperature in Kelvin.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::WBColorTemperature() const
+ {
+ return iImpl->WBColorTemperature();
+ }
+
+/**
+Set the white balance as a temperature in Kelvin
+
+@param aColorTemperature
+ white balance value as a temperature in Kelvins.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetWBColorTemperature(TInt aColorTemperature)
+ {
+ iImpl->SetWBColorTemperature(aColorTemperature);
+ }
+
+/**
+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.
+*/
+EXPORT_C TInt CCamera::CCameraAdvancedSettings::IsFlashReady(TBool& aReady) const
+ {
+ aReady = EFalse;
+ if(iImpl2 != NULL)
+ {
+ return iImpl2->IsFlashReady(aReady);
+ }
+ return KErrNotSupported;
+ }
+
+/**
+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 may be returned and TValueInfo may be ENotActive;
+ corresponding getter/setters for this feature should not be used in such a case.
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const
+ {
+ if(iImpl2 != NULL)
+ {
+ iImpl2->GetCurrentFocusModeStepsL(aFocusModeSteps, aInfo);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 KErrNotSupported if the implementation of this method is not present. May leave as a result of some other error.
+
+@note When concrete implementation is provided, but camera device does not support this feature, then aSupportedISORateTypes retrieves EISONone.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetSupportedISORateTypeL(aSupportedISORateTypes);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@leave KErrNotSupported if the implementation of this method is not present.
+
+@note Triggers KUidECamEventCameraSettingIsoRateType to all MCameraObserver2 clients of the camera.
+ HandleEvent is used to report the result or any possible error. New setter functions leave only when
+ implementation is not there.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetISORateL(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->SetISORate(aISORateType, aParam);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 is retrieved indicating the incapability of camera.
+
+@leave KErrNotSupported if the implementation of this method is not present.
+ May leave as a result of some other error.
+
+@note When concrete implementation is provided, but camera device does not support this feature, then aISORateType retrieves EISONone.
+
+@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 is retrieved as KErrNotFound.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetISORateL(aISORateType, aParam, aISORate);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Provide reference screen for orientation information.
+
+@param aScreenDevice
+ A reference to the screen device.
+
+@leave KErrNotSupported if the implementation of this method is not present.
+
+@note Triggers KUidECamEventCameraSettingReferenceScreen to all MCameraObserver2 clients of the camera.
+ HandleEvent is used to report the result or any possible error. New setter functions leave only when
+ implementation is not there.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetReferenceScreenL(CWsScreenDevice& aScreenDevice)
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->SetReferenceScreen(aScreenDevice);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 KErrNotSupported if the implementation of this method is not present.
+ KErrNoMemory if out of memory. May leave as a result of some other error.
+
+@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 concrete implementation is provided, but camera device does not support this feature, empty array may be returned and
+ TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo,
+ TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetDigitalZoomStepsForStillL(aDigitalZoomSteps, aInfo, aSizeIndex, aFormat, aIsInfluencePossible);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 KErrNotSupported if the implementation of this method is not present.
+ KErrNoMemory if out of memory. May leave as a result of some other error.
+
+@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 concrete implementation is provided, but camera device does not support this feature, empty array may be returned and
+ TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo,
+ TInt aFrameRateIndex, TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible,
+ CCamera::TExposure aExposure) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetDigitalZoomStepsForVideoL(aDigitalZoomSteps, aInfo, aFrameRateIndex, aSizeIndex, aFormat, aIsInfluencePossible, aExposure);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode aCameraMode, TInt& aPreCaptureWarningSupported) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetPreCaptureWarningSupportedL(aCameraMode, aPreCaptureWarningSupported);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ aPreCaptureWarningSupported &= KBaselinedPreCaptureWarning;
+ }
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@leave KErrNotSupported if the implementation of this method or the feature is not supported.
+ May also leave as a result of other errors.
+
+@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.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SubscribeToPreCaptureWarningL(TInt aPreCaptureWarning)
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->SubscribeToPreCaptureWarningL(aPreCaptureWarning);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Unsubscribe so that further events are not received when warnings get issued.
+
+@leave KErrNotSupported if the implementation of this method or the feature is not supported.
+ May also leave as a result of other errors.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::UnSubscribePreCaptureWarningL()
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->UnSubscribePreCaptureWarningL();
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Get the status of every warnings defined.
+
+@param aPreCaptureWarning
+ A reference to the integer - bitfield representing all the TPreCaptureWarning types issued.
+
+@leave KErrNotSupported if the implementation of this method or the feature is not supported.
+ May also leave as a result of other errors.
+
+@note This method may be called after receiving the event KUidECamEventCameraSettingPreCaptureWarning OR
+ user may also opt for polling on this.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetPreCaptureWarningL(TInt& aPreCaptureWarning) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetPreCaptureWarningL(aPreCaptureWarning);
+
+ /* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
+ application is not prepared to receive extra added enum values. So, any extra enum value passed
+ from the implementation will be filtered at this point.
+ To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
+ to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ aPreCaptureWarning &= KBaselinedPreCaptureWarning;
+ }
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 KErrNotSupported if the implementation of this method is not supported.
+ May also leave as a result of other errors.
+
+@note When concrete implementation is provided, but camera device does not support this feature,
+ then aSupportedAFAssistantLight retrieves EAFAssistantLightOff. Corresponding getter/setters for this feature should not be called then.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetSupportedAFAssistantLightL(aSupportedAFAssistantLight);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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 KErrNotSupported if the implementation of this method or the feature is not supported.
+ May also leave as a result of other errors.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& aAFAssistantLight) const
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->GetAFAssistantLightL(aAFAssistantLight);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@leave KErrNotSupported if the implementation of this method is not present.
+
+@note Triggers KUidECamEventCameraSettingAFAssistantLight to all MCameraObserver2 clients of the camera.
+ HandleEvent is used to report the result or any possible error. New setter functions leave only when
+ implementation is not there.
+
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)
+ {
+ if(iImpl3 != NULL)
+ {
+ iImpl3->SetAFAssistantLight(aAFAssistantLight);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedContinuousZoomTypeL(TUint& aSupportedContinuousZoomType) const
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->GetSupportedContinuousZoomTypeL(aSupportedContinuousZoomType);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetFocalLengthInfoL(TInt& aMinFocalLength, TInt& aCurrentFocalLength, TInt& aMaxFocalLength) const
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->GetFocalLengthInfoL(aMinFocalLength, aCurrentFocalLength, aMaxFocalLength);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetNumOperationPreferenceL(TUint& aNumOperationPreferenceSupported) const
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->GetNumOperationPreferenceL(aNumOperationPreferenceSupported);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::EnumerateOperationPreferenceL(TUint aOperationPreferenceIndex, CCamera::
+ CCameraAdvancedSettings::TPerformanceLevel& aSpeedLevel, CCamera::CCameraAdvancedSettings::
+ TPerformanceLevel& aQualityLevel, CCamera::CCameraAdvancedSettings::TPerformanceLevel&
+ aLowMemoryConsumptionLevel, CCamera::CCameraAdvancedSettings::TPerformanceLevel& aLowPowerConsumptionLevel) const
+
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->EnumerateOperationPreferenceL(aOperationPreferenceIndex, aSpeedLevel, aQualityLevel,
+ aLowMemoryConsumptionLevel, aLowPowerConsumptionLevel);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventCameraSettingOperationPreference is used to notify clients about setting an operation preference.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::SetOperationPreferenceL(TUint aOperationPreferenceIndex)
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->SetOperationPreference(aOperationPreferenceIndex);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Get the current operation preference being used.
+
+@param aOperationPreferenceIndex
+ Currently used operation preference index.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetOperationPreferenceL(TInt& aOperationPreferenceIndex) const
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->GetOperationPreferenceL(aOperationPreferenceIndex);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Retrieves the event uids which the underlying implementation supports. Client may use these event 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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetSupportedEventsL(RArray<TUid>& aSupportedEvents) const
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->GetSupportedEventsL(aSupportedEvents);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+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.
+
+@publishedPartner
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::GetIndirectFeatureChangesL(TUid aRequestedSetting, RArray<TUid>& aIndirectFeatureChanges) const
+ {
+ if(iImpl4 != NULL)
+ {
+ iImpl4->GetIndirectFeatureChangesL(aRequestedSetting, aIndirectFeatureChanges);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Creates an instance of a CCameraContinuousZoom object and returns it to the client. Ownership of the object is passed to the client.
+
+@param aObserver
+ Reference to a continuous zoom observer which will be used to issue callbacks to the client.
+
+@param aContinuousZoomType
+ The continuous zoom type with which the continuous zoom object will be initialised.
+
+@param aContinuousZoom
+ Retrieves pointer to the continuous zoom object. Client assumes ownership of the object.
+
+@note Client must not delete the continuous zoom object if CCameraContinuousZoom::StartContinuousZoomL() has been called as MContinuousZoomObserver callbacks
+ are still expected by the implementation. Clients should therefore only delete the object once the MContinuousZoomObserver::ContinuousZoomCompleted()
+ callback has been received or has explicitly stopped the continuous zoom via StopContinuousZoom().
+
+@internalTechnology
+@prototype
+*/
+EXPORT_C void CCamera::CCameraAdvancedSettings::CreateContinuousZoomL(MContinuousZoomObserver& aObserver, TContinuousZoomType aContinuousZoomType, CCameraContinuousZoom*& aContinuousZoom)
+ {
+ if(iImpl4 != NULL)
+ {
+ MImplementationFactory* implFactory = NULL;
+
+ iImpl4->CreateContinuousZoomImplFactoryL(implFactory);
+
+ CleanupReleasePushL(*implFactory);
+ CCameraContinuousZoom* zoom = CCameraContinuousZoom::CreateL(aObserver, aContinuousZoomType, *implFactory);
+ CleanupStack::Pop(implFactory);
+
+ implFactory->Release();
+ aContinuousZoom = zoom;
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+/**
+Register the ECAM component wide events in order to decide which events the client needs to be notified about.
+Previously registered events will be overridden and not augmented.
+
+@param aEventFilter
+ This is of type TECAMEventFilterScheme.
+ If EECAMEventFilterSchemeBlackList, the client will not be notified only for the events packed in the array 'aEvents'.
+ If EECAMEventFilterSchemeWhiteList, the client will be notified only for the events packed in the array 'aEvents'.
+
+@param aEvents
+ An array of events provided by the client. Helps in filtering the events for notification purposes. An empty array
+ indicates that there are no events to register for a particular filtering scheme as given by aEventFilter.
+
+@leave May leave with any error code.
+
+@note Method RegisterEvents if called with EECAMEventFilterSchemeBlackList will wipe away any white listed events set
+ previously and make them inactive.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::RegisterEventsL(TECAMEventFilterScheme /*aEventFilter*/, const RArray<TUid>& /*aEvents*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Retrieve the list of ECAM component wide events for a particular event filtering scheme.
+
+@param aEventFilter
+ This is of type TECAMEventFilterScheme.
+ If EECAMEventFilterSchemeBlackList, retrieve the events which are not supposed to be used for notification.
+ If EECAMEventFilterSchemeWhiteList, retrieve the events which are supposed to be used for notification.
+
+@param aEvents
+ An array of events given to the clients. Helps in filtering the events for notification purposes. An empty array
+ indicates that no events have been registered so far.
+
+@param aInfo
+ Retrieved TValueInfo.
+ This will be ENotActive if no event has been yet registered under the 'aEventFilter' filter scheme.
+ This will be EDiscreteSteps if some events have been registered under the 'aEventFilter' filter scheme.
+
+@leave May leave with any error code.
+
+@note There should be consistency in the information retrieved when GetRegisteredEvents is consecutively called,
+ first for blacklisted events and secondly, for white listed events. Only one of them should be used at a time and
+ hence, for the other one, aInfo will be ENotActive.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetRegisterEventsL(TECAMEventFilterScheme /*aEventFilter*/, RArray<TUid>& /*aEvents*/, TValueInfo& /*aInfo*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Retrieves the supported flicker removal values.
+
+@param aSupportedFlickerRemovalValue
+ A bitfield of all supported TFlickerRemoval to be provided to the client.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetSupportedFlickerRemovalValueL(TUint& /*aSupportedFlickerRemovalValue*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Get the current flicker removal value being used.
+
+@param aFlickerRemovalValue
+ Currently used TFlickerRemoval value.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetFlickerRemovalValueL(CCamera::CCameraAdvancedSettings::TFlickerRemoval& /*aFlickerRemovalValue*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Set the flicker removal value.
+
+@param aFlickerRemovalValue
+ The TFlickerRemoval value to be set.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventCameraSettingFlickerRemovalValue is used to notify clients about the flicker removal value
+ setting operation.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetFlickerRemovalValueL(CCamera::CCameraAdvancedSettings::TFlickerRemoval /*aFlickerRemovalValue*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Retrieves the supported neutral density filter.
+
+@param aSupportedNDFilter
+ A bitfield of all supported TNDFilter to be provided to the client.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetSupportedNDFilterL(TUint& /*aSupportedNDFilter*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Get the current neutral density filter being used.
+
+@param aNDFilter
+ Currently used TNDFilter.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetNDFilterL(CCamera::CCameraAdvancedSettings::TNDFilter& /*aNDFilter*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Set the neutral density filter.
+
+@param aNDFilter
+ The TNDFilter value to be set.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventCameraSettingNDFilter is used to notify clients about the neutral density setting operation.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetNDFilterL(CCamera::CCameraAdvancedSettings::TNDFilter /*aNDFilter*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Get the type of LED effect being used for a particular LED event.
+
+@param aLEDEvent
+ The TLEDEvent for which the current LED effect has to be retrieved.
+
+@param aLEDEffect
+ The TLEDEffect which is being used for the given LED event.
+ If this is TLEDEffectCustom, then a custom LED effect would have been separately specified by the client.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetLEDEffectL(CCamera::CCameraAdvancedSettings::TLEDEvent /*aLEDEvent*/,
+ CCamera::CCameraAdvancedSettings::TLEDEffect& /*aLEDEffect*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Set the LED effect for a particular LED event.
+
+@param aLEDEvent
+ The TLEDEvent for which the LED effect has to be set.
+
+@param aLEDEffect
+ The TLEDEffect which has to be set for the given LED event. It should not be TLEDEffectCustom.
+ Use the method SetLEDCustomEffectL() to provide the custom LED effect.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventCameraSettingLEDEffect is used to notify clients about the LED effect setting operation.
+
+@note The event will provide error code KErrArgument if TLEDEffectCustom is used as the TLEDEffect. Use the method
+ SetLEDCustomEffectL() to provide the custom LED effect.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetLEDEffectL(CCamera::CCameraAdvancedSettings::TLEDEvent /*aLEDEvent*/,
+ CCamera::CCameraAdvancedSettings::TLEDEffect /*aLEDEffect*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Set the custom LED effect for a particular LED event.
+
+@param aLEDEvent
+ The TLEDEvent for which the custom LED effect has to be set.
+
+@param aLEDSpecialEffectSteps
+ An array of custom LED special effect steps. Every member of this array is of type TECamLEDSpecialEffectStep.
+ The array as a whole constitues a custom LED effect.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventCameraSettingLEDCustomEffect is used to notify clients about the LED effect setting operation.
+
+@note Successful setting of a custom LED effect means that the GetLEDEffectL will retrieve TLEDEffectCustom for the
+ LEDEvent aLEDEvent.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetLEDCustomEffectL(CCamera::CCameraAdvancedSettings::TLEDEvent /*aLEDEvent*/,
+ const RArray<CCamera::CCameraAdvancedSettings::TECamLEDSpecialEffectStep>& /*aLEDSpecialEffectSteps*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Reserve method which are less strict than existing Reserve methods and hence, expects implementation to be considerate towards camera access/control.
+
+@param aMaxTimeToWait
+ Maximum specified time for the client to hold the camera control before releasing (KUidECamEvent2CameraRequestTimedTakeOver)
+ or being forcefully overtaken (KUidECamEvent2CameraRequestForcedTimedTakeOver).
+
+@param aKickOut
+ ETrue indicates that if the requester's priority is greater than the current reserver's, then
+ KUidECamEvent2CameraRequestForcedTimedTakeOver will be issued to the current reserver. Otherwise,
+ KUidECamEvent2CameraRequestTimedTakeOver will be issued.
+
+ EFalse indicates that KUidECamEvent2CameraRequestTimedTakeOver will be issued to the current reserver.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventNewReserveComplete notifies the client who made the new Reserve request.
+ Error value KErrECamHighPriorityReserveRequesterExists indicates another such reserve request is outstanding
+ and has higher priority than this one.
+ Error value KErrCancel indicates a new reserve requester with a higher priority than the current requester has
+ been made and that the current requester has been cancelled.
+
+@note Event KUidECamEvent2CameraRequestForcedTimedTakeOver notifies the current reserver client about its camera control
+ being forcefully overtaken after a specified time period.
+
+@note Event KUidECamEvent2CameraRequestTimedTakeOver notifies the current reserver client about a request to release its
+ camera control within a specified time period.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::ReserveL(const TTimeIntervalMicroSeconds32& /*aMaxTimeToWait*/, TBool /*aKickOut*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Sets the priority of the client. The client issues this call when it receives the notification
+KUidECamEvent2CameraSettingChangeClientPriority. The target priority is also supplied with this notification as iParam.
+
+@param aPriority
+ The target priority.
+
+@note For example, a higher priority client is currently holding the camera and a lower priority legacy
+ application is continuously requesting to get hold of it. After receiving a number of repeated requests by the
+ same legacy client, the supportive ECam implementation issues the notification
+ KUidECamEvent2CameraSettingChangeClientPriority. After receiving this notification, the client issues this method
+ SetClientPriorityL(TInt aPriority).
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetClientPriorityL(TInt /*aPriority*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Restores the priority of the client. The client issues this call when it receives the notification
+KUidECamEventCameraSettingRestoreClientPriority. ECam's responsibility is to save the original priority of the client.
+
+@note Once the legacy client has released the camera (after changing its priority), implementation will notify the
+ client to restore its priority by event KUidECamEventCameraSettingRestoreClientPriority. After receiving this
+ notification, the client issues this method RestoreClientPriorityL().
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::RestoreClientPriorityL()
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Retrieves the supported manual gain for a particular color channel.
+
+@param aSupportedManualGain
+ An array of manual gain. The TInt represent the unit in 'db' and multiplied by KECamFineResolutionFactor. Empty
+ array indicates that feature is not supported.
+
+@param aColorChannel
+ The TColorChannel for which the supported manual gain values have to be retrieved.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetSupportedManualGainL(RArray<TInt>& /*aSupportedManualGain*/,
+ CCamera::CCameraAdvancedSettings::TColorChannel /*aColorChannel*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Get the current manual gain value to be used for a particular color channel.
+
+@param aManualGain
+ Currently used manual gain value. The TInt represents the unit in 'db' and multiplied by KECamFineResolutionFactor.
+
+@param aColorChannel
+ The color channel for which the manual gain value has to be used.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetManualGainL(TInt& /*aManualGain*/,
+ CCamera::CCameraAdvancedSettings::TColorChannel /*aColorChannel*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Set the manual gain value for a particular color channel.
+
+@param aManualGain
+ The manual gain value to be set. The TInt represents the unit in 'db' and multiplied by KECamFineResolutionFactor.
+
+@param aColorChannel
+ Represents the color channel for which the manual gain value has to be set.
+
+@leave KErrNotSupported if the implementation of this method is not present.
+
+@note Event KUidECamEvent2CameraSettingManualGain is used to notify clients about the manual gain setting operation.
+
+@note The client will be expected to use either RBG color channel or YUV color channel in order to apply manual gain.
+ If the client sets manual gain values for both the color space, it is up to the implementation to decide which
+ values to use.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetManualGainL(TInt /*aManualGain*/,
+ CCamera::CCameraAdvancedSettings::TColorChannel /*aColorChannel*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Control the white balance lock. It can be either locked or unlocked.
+The white balance can be locked after aiming at a white or grey card. This helps in using the same white balance
+setting for the next image shots.
+
+@param aEnableLock
+ ETrue instructs to lock the white balance.
+ EFalse instructs to unlock the white balance.
+
+@leave KErrNotSupported If the implementation of this method is not present.
+
+@note Event KUidECamEventCameraSettingLockWhiteBalance is used to notify clients about setting the state
+ of white balance lock.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SetWhiteBalanceLockL(TBool /*aEnableLock*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Get the current state for the white balance lock.
+
+@param aIsLocked
+ A TBool specifies whether the white balance has been locked or unlocked.
+ ETrue indicates that the white balance has been locked.
+ EFalse indicates that the white balance has been unlocked.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::GetWhiteBalanceLockStateL(TBool& /*aIsLocked*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Instructs the implementation to continuously save the current state before releasing the camera or being overtaken.
+
+@param aLatestCameraState
+ A RWriteStream reference which will be used by the implementation to continuously save the latest camera state.
+
+@note The RWriteStream gives the implementation the facility to seek and overwrite any incorrectly updated state (in
+ the event of power failure, for example). Given stream sink shall support repositioning.
+
+@note The ECam client should be careful not to use the saved state for a particular camera in order to restore a
+ different camera later on. Though the implementation will be expected to take care of such things since the
+ content of the files are only meaningful for the implementation.
+
+@note The RWriteStream reference is not valid across the process.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::EnableStateSavingL(RWriteStream& /*aLatestCameraState*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Instructs the implementation to stop saving the current state in the RWriteStream& as given by
+EnableStateSavingL(RWriteStream& aLatestCameraState).
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::DisableStateSavingL()
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Instructs the implementation to resume from the last saved state. This may be used after reserving the camera.
+
+@param aLatestCameraState
+ A RReadStream reference which will be used by the implementation to restore the latest saved camera state information.
+
+@note The RReadStream gives the implementation the facility to seek and overwrite any incorrectly updated state (in
+ the event of power failure, for example).
+
+@note The ECam client should be careful not to use the saved state for a particular camera in order to restore a
+ different camera later on. Though the implementation will be expected to take care of such things since the
+ content of the files are only meaningful for the implementation.
+
+@note The RReadStream reference is not valid across the process.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::RestoreLatestStateL(RReadStream& /*aLatestCameraState*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Instructs the implementation to save the current state which will be used by the client as a custom user state.
+The state saving will be done only once when this call is issued. Many such custom state could be created by the
+clients.
+
+@param aCustomCameraState
+ A RWriteStream reference which will be used by the implementation to save the current camera state as a milestone.
+
+@note The ECam client should be careful not to use the saved state for a particular camera in order to restore a
+ different camera later on. Though the implementation will be expected to take care of such things since the
+ content of the files are only meaningful for the implementation.
+
+@note The RWriteStream reference is not valid across the process.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::SaveCameraStateL(RWriteStream& /*aCustomCameraState*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Instructs the implementation to stop saving the custom state in the RWriteStream& as given by
+SaveCameraStateL(RWriteStream& aCustomCameraState).
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::DisableCameraStateSavingL(RWriteStream& /*aCustomCameraState*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Instructs the implementation to restore a custom saved state.
+The camera can be restored in any of the custom camera states saved earlier.
+
+@param aCustomCameraState
+ A RReadStream reference which will be used by the implementation to restore a custom camera state
+ which was saved earlier.
+
+@note The ECam client should be careful not to use the saved state for a particular camera in order to restore a
+ different camera later on. Though the implementation will be expected to take care of such things since the
+ content of the files are only meaningful for the implementation.
+
+@note The RReadStream reference is not valid across the process.
+
+@leave May leave with any error code.
+
+@publishedPartner
+@prototype
+*/
+void CCamera::CCameraAdvancedSettings::RestoreCameraStateL(RReadStream& /*aCustomCameraState*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+Constructor for the TECamLEDSpecialEffectStep class.
+Sets the size and version of this class.
+*/
+CCamera::CCameraAdvancedSettings::TECamLEDSpecialEffectStep::TECamLEDSpecialEffectStep()
+ {
+ iSize = sizeof(CCamera::CCameraAdvancedSettings::TECamLEDSpecialEffectStep);
+ iVersion = KECamLEDSpecialEffectStepCurrentVersion;
+ iBlinkingFrequency = 0;
+ iIntensity = 0;
+ iFrequencyStep = 0;
+ iDuration = 0;
+ }
+
+/**
+Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.
+Intended to be used for implementation of methods where this class reference is passed as function arguments.
+Implementation of such methods can find out whether the actual class passed is the base or the derived one. For example, if a new application
+is made to run on an old implementation, an error may occur once the old implementation detects this by getting
+the size information of the T class passed. Also, if an old application is made to run on a new implementation, this can be
+correctly handled if the derived class variables handling is done in a proper 'if-else' statement.
+
+@return The size of the class.
+
+@note The size will be modified when the T-class gets updated.
+*/
+TUint CCamera::CCameraAdvancedSettings::TECamLEDSpecialEffectStep::Size() const
+ {
+ return iSize;
+ }
+
+/**
+Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved
+members get used at a later stage.
+
+@return The version of the class.
+
+@note The version will be modified when the T-class gets updated.
+*/
+TUint CCamera::CCameraAdvancedSettings::TECamLEDSpecialEffectStep::Version() const
+ {
+ return iVersion;
+ }
+
+/**
+Constructor for the TContinuousZoomSupportInfo class.
+Sets the size and version of this class.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo::TContinuousZoomSupportInfo()
+ {
+ iSize = sizeof(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo);
+ iVersion = KContinuousZoomSupportInfoCurrentVersion;
+ }
+
+/**
+Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.
+Intended to be used for implementation of methods where this class reference is passed as function arguments.
+Implementation of such methods can find out whether the actual class passed is the base or the derived one. For example, if a new application
+is made to run on an old implementation, an error may occur once the old implementation detects this by getting
+the size information of the T class passed. Also, if an old application is made to run on a new implementation, this can be
+correctly handled if the derived class variables handling is done in a proper 'if-else' statement.
+
+@return The size of the class.
+
+@note The size will be modified when the T-class gets updated.
+*/
+EXPORT_C TUint CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo::Size() const
+ {
+ return iSize;
+ }
+
+/**
+Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved
+members get used at a later stage.
+
+@return The version of the class.
+
+@note The version will be modified when the T-class gets updated.
+*/
+EXPORT_C TUint CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo::Version() const
+ {
+ return iVersion;
+ }
+
+/**
+Constructor for the TContinuousZoomParameters class.
+Sets the size and version of this class.
+*/
+EXPORT_C CCamera::CCameraAdvancedSettings::TContinuousZoomParameters::TContinuousZoomParameters()
+ {
+ iSize = sizeof(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters);
+ iVersion = KContinuousZoomParametersCurrentVersion;
+ }
+
+/**
+Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.
+Intended to be used for implementation of methods where this class reference is passed as function arguments.
+Implementation of such methods can find out whether the actual class passed is the base or the derived one. For example, if a new application
+is made to run on an old implementation, an error may occur once the old implementation detects this by getting
+the size information of the T class passed. Also, if an old application is made to run on a new implementation, this can be
+correctly handled if the derived class variables handling is done in a proper 'if-else' statement.
+
+@return The size of the class.
+
+@note The size will be modified when the T-class gets updated.
+*/
+EXPORT_C TUint CCamera::CCameraAdvancedSettings::TContinuousZoomParameters::Size() const
+ {
+ return iSize;
+ }
+
+/**
+Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved
+members get used at a later stage.
+
+@return The version of the class.
+
+@note The version will be modified when the T-class gets updated.
+*/
+EXPORT_C TUint CCamera::CCameraAdvancedSettings::TContinuousZoomParameters::Version() const
+ {
+ return iVersion;
+ }
+
+
+/**
+Factory function that creates a new continuous zoom object.
+
+@param aObserver
+ Continuous zoom observer which is passed to the implementation so it can provide callbacks to the client.
+
+@param aContinuousZoomType
+ The continuous zoom type that the implementation will be initialised with.
+
+@param aImplFactory
+ A constant reference to the MImplementationFactory derived object.
+
+@leave KErrNoMemory if out of memory; also any system wide error.
+
+@return A pointer to a fully constructed continuous zoom object.
+*/
+CCamera::CCameraContinuousZoom* CCamera::CCameraContinuousZoom::CreateL(MContinuousZoomObserver& aObserver, CCamera::CCameraAdvancedSettings::TContinuousZoomType aContinuousZoomType, const MImplementationFactory& aImplFactory)
+ {
+ CCameraContinuousZoom* self = new (ELeave) CCameraContinuousZoom();
+ CleanupStack::PushL(self);
+ self->ConstructL(aObserver, aContinuousZoomType, aImplFactory);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/**
+CCameraContinuousZoom Constructor.
+*/
+CCamera::CCameraContinuousZoom::CCameraContinuousZoom()
+ : iImpl(NULL)
+ {
+ }
+
+/**
+CCameraContinuousZoom second phase constructor.
+
+Function used to initialise internal state of the object.
+
+@param aObserver
+ Continuous zoom observer which is passed to the implementation so it can provide callbacks to the client.
+
+@param aContinuousZoomType
+ The continuous zoom type that the implementation will be initialised with.
+
+@param aImplFactory
+ A constant reference to the MImplementationFactory derived object.
+
+@leave KErrNoMemory Out of memory.
+*/
+void CCamera::CCameraContinuousZoom::ConstructL(MContinuousZoomObserver& aObserver, CCamera::CCameraAdvancedSettings::TContinuousZoomType aContinuousZoomType, const MImplementationFactory& aImplFactory)
+ {
+ TAny* implPtr = NULL;
+ TInt zoomTypeValue = static_cast<TInt>(aContinuousZoomType);
+ TECamImplFactoryParam param(zoomTypeValue);
+
+ User::LeaveIfError(aImplFactory.GetImpl1(implPtr, KECamMCameraContinuousZoomUid, param));
+
+ iImpl = static_cast<MCameraContinuousZoom*>(implPtr);
+
+ iImpl->SetContinuousZoomObserverAndHandle(aObserver, this);
+ }
+
+/**
+Destructor
+*/
+EXPORT_C CCamera::CCameraContinuousZoom::~CCameraContinuousZoom()
+ {
+ if(iImpl != NULL)
+ {
+ iImpl->Release();
+ }
+ }
+
+/**
+Starts the continuous zoom operation. Clients wil receive MContinuousZoomObserver::ContinuousZoomProgress() callback for intermediate
+zoom factors achieved. Depending on the implementation, the client may or may not receive this callback for every intermediate zoom factor.
+Upon completion, the client will receive 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.
+*/
+EXPORT_C void CCamera::CCameraContinuousZoom::StartContinuousZoomL(CCamera::CCameraAdvancedSettings::TContinuousZoomParameters aContinuousZoomParameters)
+ {
+ iImpl->StartContinuousZoomL(aContinuousZoomParameters);
+ }
+
+/**
+Stop any exisiting continuous zoom operation.
+Since this method is synchronous, no callback shall be issued for the concerned continuous zoom operation.
+*/
+EXPORT_C void CCamera::CCameraContinuousZoom::StopContinuousZoom()
+ {
+ iImpl->StopContinuousZoom();
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraContinuousZoom::GetContinuousZoomSupportInfoL(CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo& aContinuousZoomInfo) const
+ {
+ iImpl->GetContinuousZoomSupportInfoL(aContinuousZoomInfo);
+ }
+
+/**
+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.
+*/
+EXPORT_C void CCamera::CCameraContinuousZoom::GetContinuousZoomId(TInt& aZoomId) const
+ {
+ iImpl->GetContinuousZoomId(aZoomId);
+ }