// 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