// ECamAdvSetTest.cpp

// 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 <fbs.h>

#include <ecamuids.hrh>

#include "ECamUnitTestPluginUids.hrh"

#include "ECamAdvSetTest.h"

#include <ecam/ecamplugin.h>

#include <ecom/ecomresolverparams.h>

#include "ECamUnitTestPlugin.h"

#include "AdvancedSettings.h"

#include <ecam/cameraoverlay.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ecamconst.h>

#include <ecamadvsettingsconst.h>

#endif

const TInt KShutterSpeed = 20;

const TInt KIsoRate01  	= 320;

const TInt KIsoRate0   	= 150;

const TInt KValue       = 100;

const TInt KContinuousAutoFocusTimeoutValue1 = 10000;

//const TRgb KRgbConst = TRgb(100,124,130);

const TInt KWBColorTemperature1       = 4300;

const TInt KDefaultIsoRating    	  = 200;

const TInt KDefaultAperture					= 280;

const TInt KAllPreCaptureWarnings			= 0x3FFF;

const TInt KBaselinedFocusRanges 			= 0x1F;

const TInt KBaselinedWhiteBalanceModes 		= 0x01FF;

const TInt KFlashCompensationStep			= 2;

const TInt KFlashCompensationInSteps		= 1;

const TInt KExposureCompensationStep		= 3;

const TInt KExposureCompensationInSteps		= 2;

const TInt KAutoISOTypes					=0x1E;

/*

const TInt KDefaultValue					= 0;

const TInt KContinuousAutoFocusTimeoutValue = 20000;

const TInt KBrightnessAdjMinValue			= -50;

const TInt KBrightnessAdjMaxValue			= 50;

const TInt KMaxIsoRate						= 200;

const TInt KMinIsoRate						= 0;

const TInt KDefaultShutterSpeed				= 0;

const TInt KDefaultFocusDistance			= 0;

const TInt KBracketStartIndex				= 0;

const TInt KBracketFrames					= 2;

const TBool KDefaultRedEyeReduce			= EFalse;

const TBool KExternalFlashPresentState		= EFalse;

const TInt KManualFlashPowerLevel			= 0;

const TBool KApertureExposureLockOn         = EFalse;

const TBool KShootClickOn					= EFalse;

const TInt KTimerInterval					= 0;

const TInt KBurstImages						= 0;

const TBool KExposureLockOn         		= EFalse;

const TBool KAutoFocusLockOn         		= EFalse;

const TBool KAutomaticSizeSelectionChangeOn	= EFalse;

const TInt KWBColorTemperature				= 6000;

*/

//

// RECamAdvSetTest

//

RECamAdvSetTest* RECamAdvSetTest::NewL(TBool aAllocTest)

	{

	RECamAdvSetTest* self = new (ELeave) RECamAdvSetTest(aAllocTest);

	return self;	

	}

RECamAdvSetTest::RECamAdvSetTest(TBool /*aAllocTest*/)

	{

	iTestStepName = _L("MM-ECM-ADV-U-005-HP");

	}

TVerdict RECamAdvSetTest::DoTestStepL()	

	{

	TVerdict verdict = EFail;

	INFO_PRINTF1(_L("Alloc test"));

	TInt i;

	TInt err;

	for (i = 1 ; ; i++)

		{

		__MM_HEAP_MARK;

		if (i % 5 == 0)

			{

			INFO_PRINTF2(_L("Fail count = %d"), i);

			}

		__UHEAP_SETFAIL(RHeap::EFailNext, i);

		TRAP(err, verdict = DoAdvTestStepL());

		TAny* testAlloc = User::Alloc(1);

		TBool heapTestingComplete = (testAlloc == NULL) && (err==KErrNone);

		User::Free(testAlloc);

		__UHEAP_RESET;

		__MM_HEAP_MARKEND;

		if ((err != KErrNoMemory ) || heapTestingComplete)

			{

			INFO_PRINTF4(_L("err = %d, verdict = %d, Fail count = %d"), err, verdict, i);

			INFO_PRINTF1(_L("Alloc testing completed successfully"));

			verdict = EPass;

			break;

			}

		}

	return verdict;

	}

TVerdict RECamAdvSetTest::DoAdvTestStepL()

	{	

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	CCamera::CCameraAdvancedSettings* settings = NULL;

	// using observer 2 if exist 

	MCameraObserver2* observer2 = NULL;

	__MM_HEAP_MARK;

	INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2"));

	TRAP(error, camera = CCamera::New2L(*observer2, 0,0));

	if (error==KErrNone)

		{

		CleanupStack::PushL(camera);

		INFO_PRINTF1(_L("Create advanced settings from CCamera object"));

		settings = 	static_cast<CCamera::CCameraAdvancedSettings*> (camera->CustomInterface(KECamAdvancedSettingUid));

	    if (settings!= NULL)

	    	{

	    	CleanupStack::PushL(settings);

	    	INFO_PRINTF1(_L("CCameraAdvancedSettings object was created")); 

	    	CleanupStack::PopAndDestroy(settings);

	    	}

	    else

    		{

    		result = EFail;

    		User::Leave(KErrNoMemory);

    		}	

		CleanupStack::PopAndDestroy(camera);

		}

	else 

		{

		INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);

		result = EFail;	

		User::Leave(KErrNoMemory);	

		}

	__MM_HEAP_MARKEND;

	// create a settings object using New2L

	__MM_HEAP_MARK;

	INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2"));

	TRAP(error, camera = CCamera::New2L(*observer2, 0,0));

	if (error==KErrNone)

		{

		CleanupStack::PushL(camera);

		INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()"));

		TRAP(error, settings  = CCamera::CCameraAdvancedSettings::NewL(*camera));	

		if (error==KErrNone)

	    	{

	    	CleanupStack::PushL(settings);

	  		INFO_PRINTF1(_L("CCameraAdvancedSettings object was created using NewL")); 

	    	CleanupStack::PopAndDestroy(settings);

	    	}

	    else

    		{

    		INFO_PRINTF1(_L("CCameraAdvancedSettings object was not created using NewL")); 

    		result = EFail;

    		User::Leave(KErrNoMemory);

    		}	

		CleanupStack::PopAndDestroy(camera);

		}

	else 

		{

		INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);

		result = EFail;	

		User::Leave(KErrNoMemory);	

		}

	__MM_HEAP_MARKEND;

	return result;

	}

RECamAdvSetNotificationTest* RECamAdvSetNotificationTest::NewL(TBool aAllocTest)

	{

	RECamAdvSetNotificationTest* self = new (ELeave) RECamAdvSetNotificationTest(aAllocTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

void RECamAdvSetNotificationTest::ConstructL()

	{

	iError = KErrNone;

	}

RECamAdvSetNotificationTest::RECamAdvSetNotificationTest(TBool /*aAllocTest*/)

	{

	iTestStepName = _L("MM-ECM-ADV-U-009-HP");

	}

TVerdict RECamAdvSetNotificationTest::DoTestStepL()

	{	

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	TInt cameraIndex = 1;

	TBool cameraPresent = EFalse;

	__MM_HEAP_MARK;

	TInt cameras = CCamera::CamerasAvailable();

	INFO_PRINTF2(_L("Available %d cameras"), cameras);

	INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2"));

	TRAP(error, camera = CCamera::New2L(*this, 0,0));

	if (error==KErrNone)

		{

		CleanupStack::PushL(camera);

		MCamManagement* extFunct = NULL;

	    // get the MCamera management inteface implementation

	    // remember it is for the purpose of this test written to 

	    // notify this camera clients... it should be a static(singlenton) 

	    // to cater for the general case, but this is just a test, not impl example. 

		extFunct = static_cast<CCamManagement*> 

			(camera->CustomInterface(KUidCameraManagementUid));

	    if (extFunct != NULL)

	    	{

	    	CleanupStack::PushL(extFunct);

	    	CCamera::CCameraAdvancedSettings* settings = static_cast<CCamera::CCameraAdvancedSettings*> (camera->CustomInterface(KECamAdvancedSettingUid));

	 		CleanupStack::PushL(settings);

	 		// enumerate camera types

	 		for (TInt index = 0; index < cameras; index++)

	 			{

	 			CCamera::CCameraAdvancedSettings::TCameraType type = settings->CameraType(index);

	 			INFO_PRINTF3(_L("camera with index %d type %d"), index, type);

	 			if (type == CCamera::CCameraAdvancedSettings::ECameraUnknown)

	 				{

	 				result = EFail;

	 				}

	 			}

	 		// check that indexed and non indexed versions work produce the same result

	 		INFO_PRINTF1(_L("Check that indexed and non indexed versions work in the same way"));

	 		TInt thisCameraIndex = 	settings->CameraIndex();

	 		// camera type

	       	if (settings->CameraType() != settings->CameraType(thisCameraIndex))

	       		{

	       		INFO_PRINTF2(_L("CameraType() and CameraType(%d) produce different results"),thisCameraIndex);

	       		result = EFail;

	       		}

	       	// for this camera

			settings->IsCameraPresent();

			if (settings->IsCameraPresent() != settings->IsCameraPresent(thisCameraIndex))

	       		{

	       		INFO_PRINTF2(_L("IsCameraPresent() and IsCameraPresent(%d) produce different results"),thisCameraIndex);

	       		result = EFail;

	       		}

	       	// verify that the required camera is not present - different index	

	 		cameraPresent = settings->IsCameraPresent(cameraIndex);

	 		INFO_PRINTF3(_L("camera with index %d %d"), cameraIndex, cameraPresent);

	    	if (cameraPresent)

	    		{

	    		result = EFail;

	    		}

	    	INFO_PRINTF2(_L("Plug in camera with index %d"), cameraIndex);

	    	extFunct->PlugCameraIn(cameraIndex);

	    	CheckNotification(KUidECamEventGlobalCamera01PluggedIn, result);	    	

    		cameraPresent = settings->IsCameraPresent(cameraIndex);	

    		INFO_PRINTF3(_L("camera with index %d %d"), cameraIndex, cameraPresent);

    		if (!cameraPresent)

	    		{

	    		result = EFail;

	    		}

    		INFO_PRINTF2(_L("Plug out camera with index %d"), cameraIndex);

    		extFunct->PlugCameraOut(cameraIndex);

    	    CheckNotification(KUidECamEventGlobalCamera01PluggedOut, result);

    		cameraPresent = settings->IsCameraPresent(cameraIndex);

    		INFO_PRINTF3(_L("camera with index %d %d"), cameraIndex, cameraPresent);	

    		if (cameraPresent)

	    		{

	    		result = EFail;

	    		}

	    	CleanupStack::PopAndDestroy(settings);	

	    	CleanupStack::Pop(extFunct);

	    	extFunct->Release();

	    	}

	    else

	    	{

	    	INFO_PRINTF1(_L("Could not obtain camera management interface?"));

	    	result = EFail;

	    	}

	    CleanupStack::PopAndDestroy(camera);	

		}

	else 

		{

		INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error);

		result = EFail;		

		}

	__MM_HEAP_MARKEND;

	return result;

	}

//

// RECamAdvSetDefaultsTest //

//

RECamAdvSetDefaultsTest* RECamAdvSetDefaultsTest::NewL(TBool aAllocTest)

	{

	RECamAdvSetDefaultsTest* self = new (ELeave) RECamAdvSetDefaultsTest(aAllocTest);

	return self;	

	}

RECamAdvSetDefaultsTest::RECamAdvSetDefaultsTest(TBool)

	{

	iTestStepName = _L("MM-ECM-ADV-U-010-HP");

	}

TVerdict RECamAdvSetDefaultsTest::DoTestStepL()

	{	

	TVerdict result = EPass;

	CCamera* camera = NULL;

	TInt error = KErrNone;

	CCamera::CCameraAdvancedSettings* settings = NULL;

	__MM_HEAP_MARK;

	INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2"));

	TRAP(error, camera = CCamera::New2L(*this, 0,0));

	if (error==KErrNone)

		{

		CleanupStack::PushL(camera);

		INFO_PRINTF1(_L("Create advanced settings from CCamera object"));

		settings = 	static_cast<CCamera::CCameraAdvancedSettings*> (camera->CustomInterface(KECamAdvancedSettingUid));

	    if (settings!= NULL)

	    	{

	    	CleanupStack::PushL(settings);

	    	// Supported Focus Modes. Set default Focus Mode. Get Focus Mode.

			iInputEventUid = KUidECamEventCameraSettingFocusMode;

	    	TInt suppFocusModes = settings->SupportedFocusModes();    	

	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported Focus Modes 0x%x"), suppFocusModes); 

	    	CCamera::CCameraAdvancedSettings::TFocusMode defaultFocusMode = CCamera::CCameraAdvancedSettings::EFocusModeAuto;

			settings->SetFocusMode(defaultFocusMode);

	        CheckNotification(iInputEventUid, result);

	    	CCamera::CCameraAdvancedSettings::TFocusMode retrievedFocusMode = settings->FocusMode();  			

	    	if (defaultFocusMode != retrievedFocusMode) 

	    		{

	   		 	INFO_PRINTF3(_L("CCameraAdvancedSettings retrieved Focus Mode 0x%x is not the default 0x%x "), 

	   		 					retrievedFocusMode, defaultFocusMode); 

	    		result = EFail;

	    		}

	    	// Supported Focus Range. Set default Focus Range. Get Focus Range.

			iInputEventUid = KUidECamEventCameraSettingFocusRange;	    	

	    	TInt suppFocusRanges = settings->SupportedFocusRanges();    	

	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported Focus Ranges 0x%x"), suppFocusRanges); 

	    	CCamera::CCameraAdvancedSettings::TFocusRange defaultFocusRange = CCamera::CCameraAdvancedSettings::EFocusRangeAuto;

			settings->SetFocusRange(defaultFocusRange);

			// Check for KUidECamEventCameraSettingFocusRange.

	        CheckNotification(iInputEventUid, result);

	    	CCamera::CCameraAdvancedSettings::TFocusRange retrievedFocusRange = settings->FocusRange();

	    	if (defaultFocusRange != retrievedFocusRange) 

	    		{

	   		 	INFO_PRINTF3(_L("CCameraAdvancedSettings retrieved Focus Range 0x%x is not the default 0x%x"), 

	   		 					retrievedFocusRange, defaultFocusRange); 

	    		result = EFail;

	    		}

	        // Check for KUidECamEventCameraSettingFocusRangeTwo.

	        iInputEventUid = KUidECamEventCameraSettingFocusRange2;

			CheckNotificationTwo(iInputEventUid, result);

	    	// Supported Auto Focus Type. Set default Auto Focus Type. Get Auto Focus Type.

			iInputEventUid = KUidECamEventCameraSettingAutoFocusType;	    	

	    	TInt suppAutoFocusTypes = settings->SupportedAutoFocusTypes();   

	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported Focus Types 0x%x"), suppAutoFocusTypes); 	    		

	    	CCamera::CCameraAdvancedSettings::TAutoFocusType defaultAutoFocusType = CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff;

			settings->SetAutoFocusType(defaultAutoFocusType);

	        // Check for KUidECamEventCameraSettingAutoFocusType.

	        CheckNotification (iInputEventUid, result);

	    	CCamera::CCameraAdvancedSettings::TAutoFocusType retrievedAutoFocusType = settings->AutoFocusType() ;

	    	if (defaultAutoFocusType!=retrievedAutoFocusType) 

	    		{

		    	INFO_PRINTF3(_L("CCameraAdvancedSettings retrieved Auto Focus Type 0x%x is not the default 0x%x"), 

	    					retrievedAutoFocusType, defaultAutoFocusType);

 	    		result = EFail;

	    		}

	    	// Check for KUidECamEventCameraSettingAutoFocusTypeTwo

			iInputEventUid = KUidECamEventCameraSettingAutoFocusType2;	    	

	    	CheckNotificationTwo(iInputEventUid, result);	

	    	// Supported Auto Focus Area. Set default Auto Focus Area. Get Auto Focus Area.

			iInputEventUid = KUidECamEventCameraSettingAutoFocusArea;	    	

	    	TInt suppAutoFocusArea = settings->SupportedAutoFocusAreas();    	

	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported Focus Areas 0x%x"), suppAutoFocusArea); 	    		

	    	CCamera::CCameraAdvancedSettings::TAutoFocusArea defaultAutoFocusArea = CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto;

			settings->SetAutoFocusArea(defaultAutoFocusArea);

	        CheckNotification(iInputEventUid, result);

	    	CCamera::CCameraAdvancedSettings::TAutoFocusArea retrievedAutoFocusArea = settings->AutoFocusArea() ;

	    	if (defaultAutoFocusArea!=retrievedAutoFocusArea) 

	    		{

		    	INFO_PRINTF3(_L("CCameraAdvancedSettings retrieved Auto Focus Area  0x%x is not the default 0x%x"), 

	    					retrievedAutoFocusArea, defaultAutoFocusArea); 

	    		result = EFail;

	    		}	

	    	// Focus distance

			iInputEventUid = KUidECamEventCameraSettingFocusDistance;	    	

	    	TInt dummyFocusDistance = 3;

			settings->SetFocusDistance(dummyFocusDistance);

	        CheckNotification(iInputEventUid, result);

	    	TInt retrievedFocusDist = settings->FocusDistance();  

	    	if (dummyFocusDistance!=retrievedFocusDist) 

	    		{

		    	INFO_PRINTF3(_L("CCameraAdvancedSettings Focus distance  0x%x is not as expected 0x%x"), 

	    					dummyFocusDistance, retrievedFocusDist); 

	    		result = EFail;

	    		}	

	    	// Min Focal Length

	    	TInt minFocalLength = settings->GetMinFocalLength();    

	    	if (KErrNotSupported!=minFocalLength) 

	    		{

	    		INFO_PRINTF1(_L("Supported min Focal Length"));

	    		result = EFail;

	    		} 	    	

			// Supported Iso Rates. Set default Iso Rate. Get Iso Rate. OLD API

			iInputEventUid = KUidECamEventCameraSettingIsoRate;

			RArray<TInt> isoRates;

			TInt suppIsoRates = 0;

			settings->GetSupportedIsoRatesL(isoRates);  

			suppIsoRates =  isoRates[0];

			isoRates.Close();

			INFO_PRINTF2(_L("CCameraAdvancedSettings supported Iso Rates 0x%x"), suppIsoRates); 	    		

			TInt defaultIsoRate = KDefaultIsoRating;

			settings->SetIsoRate(defaultIsoRate);    

			CheckNotification(iInputEventUid, result);

	    	TInt retrievedIsoRate = settings->IsoRate();    		

	    	if (defaultIsoRate!=retrievedIsoRate) 

	    		{

		    	INFO_PRINTF3(_L("CCameraAdvancedSettings Iso Rate %d is not as expected %d"), 

	    					defaultIsoRate, retrievedIsoRate); 

	    		result = EFail;

	    		}

	    	CCamera::CCameraAdvancedSettings::TISORateType isoRateType; 

			TInt param =0;

			TInt isoRate =0;

	    	settings->GetISORateL(isoRateType, param, isoRate);

	    	if (isoRateType != CCamera::CCameraAdvancedSettings::EISOManual) 

	    		{

		    	INFO_PRINTF3(_L("CCameraAdvancedSettings New and Old API for Iso Rate Type not consistent  0x%x is not as expected 0x%x"), 

	    					isoRateType, CCamera::CCameraAdvancedSettings::EISOManual); 

	    		result = EFail;

	    		}

	    	if (defaultIsoRate != isoRate) 

	    		{

		    	INFO_PRINTF3(_L("CCameraAdvancedSettings New and Old API for Iso Rate not consistent %d is not as expected %d"), 

	    					isoRate, defaultIsoRate); 

	    		result = EFail;

	    		}

	       	// Supported Iso Types. Set default Iso Type. Set Default ISO Rate. Get Iso Type and Rate. New API

	    	iInputEventUid = KUidECamEventCameraSettingIsoRateType;

			TInt supportedISORateTypes = 0;

			settings->GetSupportedISORateTypeL(supportedISORateTypes);  

			INFO_PRINTF2(_L("CCameraAdvancedSettings supported Iso Rate Types 0x%x"), supportedISORateTypes); 	    		

			defaultIsoRate = KDefaultIsoRating;

			CCamera::CCameraAdvancedSettings::TISORateType defaultIsoRateType = CCamera::CCameraAdvancedSettings::EISOManual;

			if(defaultIsoRateType & supportedISORateTypes)

				{

				settings->SetISORateL(defaultIsoRateType, defaultIsoRate);

				CheckNotification(iInputEventUid, result);

				param =0;

				isoRate =0;