// Copyright (c) 2007-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:

// testadvancedsettings.cpp

// 

//

#include "test_advanced_settings.h"

#include <ecamerrors.h>

#include "ecamversion.h"

CTestCamAdvSet::CTestCamAdvSet(CTestCamera& aOwner): iOwner(aOwner)

	{

	Init();

	}

CTestCamAdvSet::~CTestCamAdvSet()

	{

	iSupportedISORates.Close();

	iSupportedApertures.Close();

	iSupportedShutterSpeeds.Close();

	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());	

	if(globalData != NULL)

		{

		if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)

			{

			delete globalData;

			Dll::FreeTls();

			}	

		else

			{

			globalData->iTestCamAdvSet = NULL;	

			Dll::SetTls(globalData);

			}

		}

	}

CTestCamAdvSet* CTestCamAdvSet::NewL(CTestCamera& aOwner)

	{

	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());

	if(globalData == NULL)

		{

		globalData = new (ELeave) CDataGlobal;

		CleanupStack::PushL(globalData);

		globalData->iAdvSetReferenceCount = 0;

		globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);

		CleanupStack::PushL(globalData->iTestCamAdvSet);

		globalData->iTestCamAdvSet->ConstructL();

		globalData->iTestCamAdvSet->iRefCount = 1;

		User::LeaveIfError(Dll::SetTls(globalData));

		CleanupStack::Pop(globalData->iTestCamAdvSet);

		CleanupStack::Pop(globalData);

		return globalData->iTestCamAdvSet;

		}

	else

		{

		if(globalData->iTestCamAdvSet == NULL)

			{

			globalData->iAdvSetReferenceCount = 0;

			globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);

			CleanupStack::PushL(globalData->iTestCamAdvSet);

			globalData->iTestCamAdvSet->ConstructL();

			globalData->iTestCamAdvSet->iRefCount = 1;

			User::LeaveIfError(Dll::SetTls(globalData));

			CleanupStack::Pop(globalData->iTestCamAdvSet);

			return globalData->iTestCamAdvSet;

			}

		CTestCamAdvSet* self = globalData->iTestCamAdvSet;

		globalData->iAdvSetReferenceCount++;

		self->iRefCount = globalData->iAdvSetReferenceCount + 1;

		if (globalData->iAdvSetReferenceCount == KNumOfAdvSetExtensions-1 )

			{

			globalData->iTestCamAdvSet = NULL;

			if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)

				{

				delete globalData;

				Dll::FreeTls();

				}

			else

				{

				User::LeaveIfError(Dll::SetTls(globalData));

				}

			}

		else

			{

			User::LeaveIfError(Dll::SetTls(globalData));

			}

		return self;		

		}

	}

void CTestCamAdvSet::Release()

	{

	iRefCount--; 

	if(iRefCount == 0)

		{

		iOwner.iAdvSettingsImpl = NULL;

		delete this;

		}

	}	

void CTestCamAdvSet::Init()

	{

	for(TUint i=0; i< KNumAvailableCameras; i++)

		{

		iCameraTypes[i] = CCamera::CCameraAdvancedSettings::ECameraPluggable;

		}

	iFocusDistance = KDefaultFocusDistance;

	iIsoRate = KDefaultIsoRate;

	iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;

	iAperture = KDefaultAperture;

	iShutterSpeed = KDefaultShutterSpeed;

	}

void CTestCamAdvSet::ConstructL()

	{

	iSupportedISORates.Reset();

	iSupportedISORates.AppendL(KDefaultIsoRate);

	iSupportedApertures.Reset();

	iSupportedApertures.AppendL(KDefaultAperture);

	iSupportedShutterSpeeds.Reset();

	iSupportedShutterSpeeds.AppendL(KDefaultShutterSpeed);

	}

CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType() const

	{

	return CCamera::CCameraAdvancedSettings::ECameraPluggable;	

	}

CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType(TInt aCameraIndex) const

	{

	if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)

		{

		return CCamera::CCameraAdvancedSettings::ECameraUnknown;	

		}

	else 

		{

		return iCameraTypes[aCameraIndex];	

		}

	}

TBool CTestCamAdvSet::IsCameraPresent() const

	{

	return ETrue;

	}

TBool CTestCamAdvSet::IsCameraPresent(TInt aCameraIndex) const

	{

	if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)

		{

		return EFalse;	

		}

	else 

		{

		return ETrue;	

		}

	}

TInt CTestCamAdvSet::CameraIndex() const

	{

	return iOwner.iCameraIndex;

	}

TInt CTestCamAdvSet::SupportedStabilizationModes() const

	{

	return KFeatureNotSupported;

	}

CCamera::CCameraAdvancedSettings::TStabilizationMode CTestCamAdvSet::StabilizationMode() const

	{

	return CCamera::CCameraAdvancedSettings::EStabilizationModeOff;

	}

void CTestCamAdvSet::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)

	{	

	TInt eventError = KErrNotSupported;

	if(aStabilizationMode == CCamera::CCameraAdvancedSettings::EStabilizationModeOff)

		{

		eventError = KErrAlreadyExists;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingStabilizationMode, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

TInt CTestCamAdvSet::SupportedFocusModes() const

	{

	return KFeatureNotSupported;

	}

CCamera::CCameraAdvancedSettings::TFocusMode CTestCamAdvSet::FocusMode() const

	{

	return CCamera::CCameraAdvancedSettings::EFocusModeAuto;	

	}

void CTestCamAdvSet::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)

	{

	TInt eventError = KErrNotSupported;

	if(aFocusMode == CCamera::CCameraAdvancedSettings::EFocusModeAuto)

		{

		eventError = KErrAlreadyExists;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingFocusMode, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

TInt CTestCamAdvSet::SupportedFocusRanges() const

	{

	return KFeatureNotSupported;

	}

CCamera::CCameraAdvancedSettings::TFocusRange CTestCamAdvSet::FocusRange() const

	{

	return CCamera::CCameraAdvancedSettings::EFocusRangeAuto;

	}

void CTestCamAdvSet::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)

	{

	TInt eventError = KErrNotSupported;

	if(aFocusRange == CCamera::CCameraAdvancedSettings::EFocusRangeAuto)

		{

		eventError = KErrAlreadyExists;

		}

	TECAMEvent ecamevent1(KUidECamEventCameraSettingFocusRange2, eventError);

	TECAMEvent ecamevent2(KUidECamEventCameraSettingFocusRange, eventError);

	iOwner.iECamEvent = ecamevent1;

	iOwner.iHandleEventAsync.CallBack();

	iOwner.iECamEvent = ecamevent2;

	iOwner.iHandleEventAsync.CallBack();

	}

TInt CTestCamAdvSet::SupportedAutoFocusTypes() const

	{

	return KFeatureNotSupported;

	}

CCamera::CCameraAdvancedSettings::TAutoFocusType CTestCamAdvSet::AutoFocusType() const

	{

    return CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff;

	}

void CTestCamAdvSet::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)

	{

	TInt eventError = KErrNotSupported;

	if(aAutoFocusType == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff)

		{

		eventError = KErrAlreadyExists;

		}

	TECAMEvent ecamevent1(KUidECamEventCameraSettingAutoFocusType2, eventError);

	TECAMEvent ecamevent2(KUidECamEventCameraSettingAutoFocusType, eventError);

	iOwner.iECamEvent = ecamevent1;

	iOwner.iHandleEventAsync.CallBack();

	iOwner.iECamEvent = ecamevent2;

	iOwner.iHandleEventAsync.CallBack();

	}

TInt CTestCamAdvSet::SupportedAutoFocusAreas() const

	{

	return KFeatureNotSupported;

	}

CCamera::CCameraAdvancedSettings::TAutoFocusArea CTestCamAdvSet::AutoFocusArea() const

	{

	return CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto;

	}

void CTestCamAdvSet::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)

	{

	TInt eventError = KErrNotSupported;

	if(aAutoFocusArea == CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto)

		{

		eventError = KErrAlreadyExists;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusArea, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

TInt CTestCamAdvSet::FocusDistance() const

	{

	return iFocusDistance;

	}

void CTestCamAdvSet::SetFocusDistance(TInt aDistance) 

	{

	TInt eventError = KErrNone;

	if(aDistance < 0)

		{

		eventError = KErrNotSupported;

		}

	else

		{

		iFocusDistance = aDistance;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingFocusDistance, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

TInt CTestCamAdvSet::GetMinFocalLength() const

	{

	return KErrNotSupported;

	}

void CTestCamAdvSet::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const

	{

	if(iSupportedISORates.Count() == 0)

		{

		User::Leave(KErrNotSupported);

		}

	for(TInt index=0; index < iSupportedISORates.Count(); index++)

		{

		aSupportedIsoRates.AppendL(iSupportedISORates[index]);

		}

	}

TInt CTestCamAdvSet::IsoRate() const

	{

	return iIsoRate; 

	}

void CTestCamAdvSet::SetIsoRate(TInt aRate)

	{

	TInt eventError = KErrNone;

	if(iSupportedISORates.Find(aRate) == KErrNotFound)

		{

		eventError = KErrECamParameterNotInRange;

		}

	else 

		{

		//set the ISO type to Manual

		iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;			

		iIsoRate = aRate;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRate, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

void CTestCamAdvSet::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const

	{

	aSupportedISORateTypes = KSupportedISORateTypes;	

	}

void CTestCamAdvSet::SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)

	{

	TInt eventError = KErrNone;

	if(!(aISORateType & KSupportedISORateTypes) || iSupportedISORates.Count() == 0)

		{

		eventError = KErrNotSupported;

		}

	else

		{

		switch(aISORateType)

			{

			case CCamera::CCameraAdvancedSettings::EISOManual:

				{

				if(iSupportedISORates.Find(aParam) == KErrNotFound)

					{

					eventError = KErrECamParameterNotInRange;

					}

				else

					{

					iISORateType = aISORateType;

					if(aParam == iIsoRate)

						{

						eventError = KErrAlreadyExists;

						}

					else

						{

						iIsoRate = aParam;

						}

					}

				break;

				}

			case CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised:

				{

				eventError = KErrNotSupported;

				break;	

				}

			case CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised:

				{

				eventError = KErrNotSupported;

				break;

				}

			case CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised:

				{

				eventError = KErrNotSupported;

				break;	

				}

			case CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised:

				{

				eventError = KErrNotSupported;

				break;	

				}

			default:

				eventError = KErrNotSupported;

			}

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRateType, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

void CTestCamAdvSet::GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& /*aParam*/, TInt& aISORate) const

	{

	//If camera has no ISO rate supported, then leave

	if(iSupportedISORates.Count() == 0)	

		{

		User::Leave(KErrNotSupported);

		}

	aISORateType = iISORateType;

	aISORate = iIsoRate;

//	aParam is redundant for manual ISO.

	}

void CTestCamAdvSet::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const

	{

	if(iSupportedApertures.Count() == 0)

		{

		aFStops.Reset();

		aInfo = ENotActive;

		}

	for(TInt index=0; index < iSupportedApertures.Count(); index++)

		{

		aFStops.AppendL(iSupportedApertures[index]);

		}

	aInfo = EDiscreteSteps;

	}

TInt CTestCamAdvSet::Aperture() const

	{

	return iAperture;

	}

void CTestCamAdvSet::SetAperture(TInt aFStop)

	{	

	TInt eventError = KErrNone;

	if(iSupportedApertures.Find(aFStop) == KErrNotFound)

		{

		eventError = KErrECamParameterNotInRange;

		}

	else 

		{

		iAperture = aFStop;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingAperture, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}	

void CTestCamAdvSet::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const

	{

	if(iSupportedShutterSpeeds.Count() == 0)

		{

		aShutterSpeeds.Reset();

		aInfo = ENotActive;

		}

	for(TInt index=0; index < iSupportedShutterSpeeds.Count(); index++)

		{

		aShutterSpeeds.AppendL(iSupportedShutterSpeeds[index]);

		aInfo = EDiscreteSteps;

		}

	}

TInt CTestCamAdvSet::ShutterSpeed() const

	{

	return iShutterSpeed;

	}

void CTestCamAdvSet::SetShutterSpeed(TInt aShutterSpeed)

	{

	TInt eventError = KErrNone;

	if(iSupportedShutterSpeeds.Find(aShutterSpeed) == KErrNotFound)

		{

		eventError = KErrECamParameterNotInRange;

		}

	else 

		{

		iShutterSpeed = aShutterSpeed;

		}

	TECAMEvent ecamevent(KUidECamEventCameraSettingShutterSpeed, eventError);