Symaptic: os/mm/imagingandcamerafws/cameraunittest/src/TSU_ECM

     2 // ECamAdvSetTest.cpp

     4 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     5 // All rights reserved.

     6 // This component and the accompanying materials are made available

     7 // under the terms of "Eclipse Public License v1.0"

     8 // which accompanies this distribution, and is available

     9 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

    10 //

    11 // Initial Contributors:

    12 // Nokia Corporation - initial contribution.

    13 //

    14 // Contributors:

    15 //

    16 // Description:

    17 //

    19 #include <fbs.h>

    21 #include <ecamuids.hrh>

    22 #include "ECamUnitTestPluginUids.hrh"

    23 #include "ECamAdvSetTest.h"

    24 #include <ecam/ecamplugin.h>

    26 #include <ecom/ecomresolverparams.h>

    27 #include "ECamUnitTestPlugin.h"

    28 #include "AdvancedSettings.h"

    29 #include <ecam/cameraoverlay.h>

    30 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    31 #include <ecamconst.h>

    32 #include <ecamadvsettingsconst.h>

    33 #endif

    35 const TInt KShutterSpeed = 20;

    36 const TInt KIsoRate01  	= 320;

    37 const TInt KIsoRate0   	= 150;

    38 const TInt KValue       = 100;

    39 const TInt KContinuousAutoFocusTimeoutValue1 = 10000;

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

    41 const TInt KWBColorTemperature1       = 4300;

    42 const TInt KDefaultIsoRating    	  = 200;

    43 const TInt KDefaultAperture					= 280;

    44 const TInt KAllPreCaptureWarnings			= 0x3FFF;

    45 const TInt KBaselinedFocusRanges 			= 0x1F;

    46 const TInt KBaselinedWhiteBalanceModes 		= 0x01FF;

    47 const TInt KFlashCompensationStep			= 2;

    48 const TInt KFlashCompensationInSteps		= 1;

    49 const TInt KExposureCompensationStep		= 3;

    50 const TInt KExposureCompensationInSteps		= 2;

    51 const TInt KAutoISOTypes					=0x1E;

    52 /*

    53 const TInt KDefaultValue					= 0;

    54 const TInt KContinuousAutoFocusTimeoutValue = 20000;

    55 const TInt KBrightnessAdjMinValue			= -50;

    56 const TInt KBrightnessAdjMaxValue			= 50;

    58 const TInt KMaxIsoRate						= 200;

    59 const TInt KMinIsoRate						= 0;

    60 const TInt KDefaultShutterSpeed				= 0;

    61 const TInt KDefaultFocusDistance			= 0;

    63 const TInt KBracketStartIndex				= 0;

    64 const TInt KBracketFrames					= 2;

    65 const TBool KDefaultRedEyeReduce			= EFalse;

    67 const TBool KExternalFlashPresentState		= EFalse;

    68 const TInt KManualFlashPowerLevel			= 0;

    69 const TBool KApertureExposureLockOn         = EFalse;

    70 const TBool KShootClickOn					= EFalse;

    71 const TInt KTimerInterval					= 0;

    72 const TInt KBurstImages						= 0;

    73 const TBool KExposureLockOn         		= EFalse;

    74 const TBool KAutoFocusLockOn         		= EFalse;

    75 const TBool KAutomaticSizeSelectionChangeOn	= EFalse;

    76 const TInt KWBColorTemperature				= 6000;

    77 */

    78 //

    79 // RECamAdvSetTest

    80 //

    81 RECamAdvSetTest* RECamAdvSetTest::NewL(TBool aAllocTest)

    82 	{

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

    84 	return self;

    85 	}

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

    88 	{

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

    90 	}

    92 TVerdict RECamAdvSetTest::DoTestStepL()

    93 	{

    94 	TVerdict verdict = EFail;

    95 	INFO_PRINTF1(_L("Alloc test"));

    96 	TInt i;

    97 	TInt err;

    98 	for (i = 1 ; ; i++)

    99 		{

   100 		__MM_HEAP_MARK;

   102 		if (i % 5 == 0)

   103 			{

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

   105 			}

   107 		__UHEAP_SETFAIL(RHeap::EFailNext, i);

   109 		TRAP(err, verdict = DoAdvTestStepL());

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

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

   113 		User::Free(testAlloc);

   115 		__UHEAP_RESET;

   116 		__MM_HEAP_MARKEND;

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

   119 			{

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

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

   122 			verdict = EPass;

   123 			break;

   124 			}

   125 		}

   126 	return verdict;

   127 	}

   129 TVerdict RECamAdvSetTest::DoAdvTestStepL()

   130 	{

   131 	TVerdict result = EPass;

   132 	CCamera* camera = NULL;

   134 	TInt error = KErrNone;

   135 	CCamera::CCameraAdvancedSettings* settings = NULL;

   137 	// using observer 2 if exist

   138 	MCameraObserver2* observer2 = NULL;

   140 	__MM_HEAP_MARK;

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

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

   143 	if (error==KErrNone)

   144 		{

   145 		CleanupStack::PushL(camera);

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

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

   148 	    if (settings!= NULL)

   149 	    	{

   150 	    	CleanupStack::PushL(settings);

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

   152 	    	CleanupStack::PopAndDestroy(settings);

   153 	    	}

   154 	    else

   155     		{

   156     		result = EFail;

   157     		User::Leave(KErrNoMemory);

   158     		}

   159 		CleanupStack::PopAndDestroy(camera);

   160 		}

   161 	else

   162 		{

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

   164 		result = EFail;

   165 		User::Leave(KErrNoMemory);

   166 		}

   167 	__MM_HEAP_MARKEND;

   169 	// create a settings object using New2L

   170 	__MM_HEAP_MARK;

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

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

   175 	if (error==KErrNone)

   176 		{

   177 		CleanupStack::PushL(camera);

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

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

   180 		if (error==KErrNone)

   181 	    	{

   182 	    	CleanupStack::PushL(settings);

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

   184 	    	CleanupStack::PopAndDestroy(settings);

   185 	    	}

   186 	    else

   187     		{

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

   189     		result = EFail;

   190     		User::Leave(KErrNoMemory);

   191     		}

   192 		CleanupStack::PopAndDestroy(camera);

   193 		}

   194 	else

   195 		{

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

   197 		result = EFail;

   198 		User::Leave(KErrNoMemory);

   199 		}

   200 	__MM_HEAP_MARKEND;

   201 	return result;

   202 	}

   204 RECamAdvSetNotificationTest* RECamAdvSetNotificationTest::NewL(TBool aAllocTest)

   205 	{

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

   207 	CleanupStack::PushL(self);

   208 	self->ConstructL();

   209 	CleanupStack::Pop(self);

   210 	return self;

   211 	}

   213 void RECamAdvSetNotificationTest::ConstructL()

   214 	{

   215 	iError = KErrNone;

   216 	}

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

   219 	{

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

   221 	}

   223 TVerdict RECamAdvSetNotificationTest::DoTestStepL()

   224 	{

   225 	TVerdict result = EPass;

   226 	CCamera* camera = NULL;

   228 	TInt error = KErrNone;

   229 	TInt cameraIndex = 1;

   230 	TBool cameraPresent = EFalse;

   232 	__MM_HEAP_MARK;

   233 	TInt cameras = CCamera::CamerasAvailable();

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

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

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

   237 	if (error==KErrNone)

   238 		{

   239 		CleanupStack::PushL(camera);

   240 		MCamManagement* extFunct = NULL;

   242 	    // get the MCamera management inteface implementation

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

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

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

   246 		extFunct = static_cast<CCamManagement*>

   247 			(camera->CustomInterface(KUidCameraManagementUid));

   249 	    if (extFunct != NULL)

   250 	    	{

   251 	    	CleanupStack::PushL(extFunct);

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

   254 	 		CleanupStack::PushL(settings);

   256 	 		// enumerate camera types

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

   258 	 			{

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

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

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

   262 	 				{

   263 	 				result = EFail;

   264 	 				}

   265 	 			}

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

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

   269 	 		TInt thisCameraIndex = 	settings->CameraIndex();

   270 	 		// camera type

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

   272 	       		{

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

   274 	       		result = EFail;

   275 	       		}

   276 	       	// for this camera

   277 			settings->IsCameraPresent();

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

   279 	       		{

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

   281 	       		result = EFail;

   282 	       		}

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

   285 	 		cameraPresent = settings->IsCameraPresent(cameraIndex);

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

   287 	    	if (cameraPresent)

   288 	    		{

   289 	    		result = EFail;

   290 	    		}

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

   293 	    	extFunct->PlugCameraIn(cameraIndex);

   294 	    	CheckNotification(KUidECamEventGlobalCamera01PluggedIn, result);

   296     		cameraPresent = settings->IsCameraPresent(cameraIndex);

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

   298     		if (!cameraPresent)

   299 	    		{

   300 	    		result = EFail;

   301 	    		}

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

   304     		extFunct->PlugCameraOut(cameraIndex);

   305     	    CheckNotification(KUidECamEventGlobalCamera01PluggedOut, result);

   307     		cameraPresent = settings->IsCameraPresent(cameraIndex);

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

   309     		if (cameraPresent)

   310 	    		{

   311 	    		result = EFail;

   312 	    		}

   314 	    	CleanupStack::PopAndDestroy(settings);

   316 	    	CleanupStack::Pop(extFunct);

   317 	    	extFunct->Release();

   318 	    	}

   319 	    else

   320 	    	{

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

   322 	    	result = EFail;

   323 	    	}

   324 	    CleanupStack::PopAndDestroy(camera);

   325 		}

   327 	else

   328 		{

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

   330 		result = EFail;

   331 		}

   332 	__MM_HEAP_MARKEND;

   333 	return result;

   334 	}

   337 //

   338 // RECamAdvSetDefaultsTest //

   339 //

   340 RECamAdvSetDefaultsTest* RECamAdvSetDefaultsTest::NewL(TBool aAllocTest)

   341 	{

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

   343 	return self;

   344 	}

   346 RECamAdvSetDefaultsTest::RECamAdvSetDefaultsTest(TBool)

   347 	{

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

   349 	}

   351 TVerdict RECamAdvSetDefaultsTest::DoTestStepL()

   352 	{

   353 	TVerdict result = EPass;

   354 	CCamera* camera = NULL;

   356 	TInt error = KErrNone;

   357 	CCamera::CCameraAdvancedSettings* settings = NULL;

   359 	__MM_HEAP_MARK;

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

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

   362 	if (error==KErrNone)

   363 		{

   364 		CleanupStack::PushL(camera);

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

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

   367 	    if (settings!= NULL)

   368 	    	{

   369 	    	CleanupStack::PushL(settings);

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

   372 			iInputEventUid = KUidECamEventCameraSettingFocusMode;

   373 	    	TInt suppFocusModes = settings->SupportedFocusModes();

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

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

   376 			settings->SetFocusMode(defaultFocusMode);

   378 	        CheckNotification(iInputEventUid, result);

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

   381 	    	if (defaultFocusMode != retrievedFocusMode)

   382 	    		{

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

   384 	   		 					retrievedFocusMode, defaultFocusMode);

   385 	    		result = EFail;

   386 	    		}

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

   389 			iInputEventUid = KUidECamEventCameraSettingFocusRange;

   390 	    	TInt suppFocusRanges = settings->SupportedFocusRanges();

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

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

   393 			settings->SetFocusRange(defaultFocusRange);

   395 			// Check for KUidECamEventCameraSettingFocusRange.

   396 	        CheckNotification(iInputEventUid, result);

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

   399 	    	if (defaultFocusRange != retrievedFocusRange)

   400 	    		{

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

   402 	   		 					retrievedFocusRange, defaultFocusRange);

   403 	    		result = EFail;

   404 	    		}

   406 	        // Check for KUidECamEventCameraSettingFocusRangeTwo.

   407 	        iInputEventUid = KUidECamEventCameraSettingFocusRange2;

   408 			CheckNotificationTwo(iInputEventUid, result);

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

   411 			iInputEventUid = KUidECamEventCameraSettingAutoFocusType;

   412 	    	TInt suppAutoFocusTypes = settings->SupportedAutoFocusTypes();

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

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

   415 			settings->SetAutoFocusType(defaultAutoFocusType);

   417 	        // Check for KUidECamEventCameraSettingAutoFocusType.

   418 	        CheckNotification (iInputEventUid, result);

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

   421 	    	if (defaultAutoFocusType!=retrievedAutoFocusType)

   422 	    		{

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

   424 	    					retrievedAutoFocusType, defaultAutoFocusType);

   425  	    		result = EFail;

   426 	    		}

   428 	    	// Check for KUidECamEventCameraSettingAutoFocusTypeTwo

   429 			iInputEventUid = KUidECamEventCameraSettingAutoFocusType2;

   430 	    	CheckNotificationTwo(iInputEventUid, result);

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

   433 			iInputEventUid = KUidECamEventCameraSettingAutoFocusArea;

   434 	    	TInt suppAutoFocusArea = settings->SupportedAutoFocusAreas();

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

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

   437 			settings->SetAutoFocusArea(defaultAutoFocusArea);

   439 	        CheckNotification(iInputEventUid, result);

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

   442 	    	if (defaultAutoFocusArea!=retrievedAutoFocusArea)

   443 	    		{

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

   445 	    					retrievedAutoFocusArea, defaultAutoFocusArea);

   446 	    		result = EFail;

   447 	    		}

   449 	    	// Focus distance

   450 			iInputEventUid = KUidECamEventCameraSettingFocusDistance;

   451 	    	TInt dummyFocusDistance = 3;

   452 			settings->SetFocusDistance(dummyFocusDistance);

   454 	        CheckNotification(iInputEventUid, result);

   456 	    	TInt retrievedFocusDist = settings->FocusDistance();

   457 	    	if (dummyFocusDistance!=retrievedFocusDist)

   458 	    		{

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

   460 	    					dummyFocusDistance, retrievedFocusDist);

   461 	    		result = EFail;

   462 	    		}

   464 	    	// Min Focal Length

   465 	    	TInt minFocalLength = settings->GetMinFocalLength();

   466 	    	if (KErrNotSupported!=minFocalLength)

   467 	    		{

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

   469 	    		result = EFail;

   470 	    		}

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

   473 			iInputEventUid = KUidECamEventCameraSettingIsoRate;

   474 			RArray<TInt> isoRates;

   475 			TInt suppIsoRates = 0;

   476 			settings->GetSupportedIsoRatesL(isoRates);

   477 			suppIsoRates =  isoRates[0];

   478 			isoRates.Close();

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

   480 			TInt defaultIsoRate = KDefaultIsoRating;

   481 			settings->SetIsoRate(defaultIsoRate);

   483 			CheckNotification(iInputEventUid, result);

   485 	    	TInt retrievedIsoRate = settings->IsoRate();

   486 	    	if (defaultIsoRate!=retrievedIsoRate)

   487 	    		{

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

   489 	    					defaultIsoRate, retrievedIsoRate);

   490 	    		result = EFail;

   491 	    		}

   493 	    	CCamera::CCameraAdvancedSettings::TISORateType isoRateType;

   494 			TInt param =0;

   495 			TInt isoRate =0;

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

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

   499 	    		{

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

   501 	    					isoRateType, CCamera::CCameraAdvancedSettings::EISOManual);

   502 	    		result = EFail;

   503 	    		}

   505 	    	if (defaultIsoRate != isoRate)

   506 	    		{

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

   508 	    					isoRate, defaultIsoRate);

   509 	    		result = EFail;

   510 	    		}

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

   513 	    	iInputEventUid = KUidECamEventCameraSettingIsoRateType;

   515 			TInt supportedISORateTypes = 0;

   516 			settings->GetSupportedISORateTypeL(supportedISORateTypes);

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

   519 			defaultIsoRate = KDefaultIsoRating;

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

   521 			if(defaultIsoRateType & supportedISORateTypes)

   522 				{

   523 				settings->SetISORateL(defaultIsoRateType, defaultIsoRate);

   525 				CheckNotification(iInputEventUid, result);

   527 				param =0;

   528 				isoRate =0;

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

   532 				if(isoRateType != defaultIsoRateType)

   533 					{

   534 					INFO_PRINTF3(_L("CCameraAdvancedSettings Iso Rate Type 0x%x is not as expected 0x%x"),

   535 	    					isoRateType, defaultIsoRateType);

   536 	    			result = EFail;

   537 					}

   539 				if(isoRate != defaultIsoRate)

   540 					{

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

   542 	    					isoRate, defaultIsoRate);

   543 	    			result = EFail;

   544 					}

   545 				}

   547 	    	// Supported apertures. Set and Get aperture.

   548 	    	iInputEventUid = KUidECamEventCameraSettingAperture;

   549 	    	RArray<TInt> suppApertures;

   550 	    	TValueInfo valueInfo = ENotActive;

   551 	    	settings->GetAperturesL(suppApertures, valueInfo);

   552 			// should not have entries

   553 			if (suppApertures.Count() != 0)

   554 				{

   555 				result = EFail;

   556 				}

   558 			TInt dummyAperture = KDefaultAperture;

   559 			settings->SetAperture(dummyAperture);

   561 	        CheckNotification(iInputEventUid, result);

   563 	    	TInt aperture = settings->Aperture() ;

   564 	    	if (dummyAperture != aperture)

   565 	    		{

   566 		    	INFO_PRINTF3(_L("CCameraAdvancedSettings Aperture  0x%x is not as expected 0x%x"),

   567 	    					dummyAperture, aperture);

   569 	    		result = EFail;

   570 	    		}

   572 	    	// Supported shutter speed. Set and Get shutter speed

   573 	    	iInputEventUid = KUidECamEventCameraSettingShutterSpeed;

   574 	    	RArray<TInt> suppShutterSpeed;

   575 	    	TValueInfo shutterSpeedValueInfo = ENotActive;

   576 	    	settings->GetShutterSpeedsL(suppShutterSpeed, shutterSpeedValueInfo );

   577 			// should not have entries

   578 			if (suppShutterSpeed.Count() != 0)

   579 				{

   580 				result = EFail;

   581 				}

   583 			TInt dummyShutterSpeed = KShutterSpeed;

   584 			settings->SetShutterSpeed(dummyShutterSpeed);

   586 	        CheckNotification(iInputEventUid, result);

   588 	    	TInt shutterSpeed = settings->ShutterSpeed() ;

   589 	    	if (dummyShutterSpeed != shutterSpeed)

   590 	    		{

   591 		    	INFO_PRINTF3(_L("CCameraAdvancedSettings Shutter Speed  0x%x is not as expected 0x%x"),

   592 	    					dummyShutterSpeed, shutterSpeed);

   594 	    		result = EFail;

   595 	    		}

   597    			// Supported Metering Modes

   598 	    	iInputEventUid = KUidECamEventCameraSettingMeteringMode;

   599 	    	TInt suppMeteringModes = settings->SupportedMeteringModes();

   600 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported Metering Modes 0x%x"), suppMeteringModes);

   601 	    	CCamera::CCameraAdvancedSettings::TMeteringMode defaultMeteringMode = CCamera::CCameraAdvancedSettings::EMeteringModeAuto;

   602 	    	settings->SetMeteringMode(defaultMeteringMode);

   604 	        CheckNotification (iInputEventUid, result);

   606 	    	CCamera::CCameraAdvancedSettings::TMeteringMode retrievedMeteringMode = settings->MeteringMode() ;

   607 	    	if (defaultMeteringMode != retrievedMeteringMode)

   608 	    		{

   609 		    	INFO_PRINTF3(_L("CCameraAdvancedSettings Metering Mode  0x%x is not as expected 0x%x"),

   610 	    					defaultMeteringMode, retrievedMeteringMode);

   611 	    		result = EFail;

   612 	    		}

   615    			// Supported Bracket Modes

   616 	    	iInputEventUid = KUidECamEventCameraSettingBracketMode;

   617 	    	TInt suppBracketModes = settings->SupportedBracketModes();

   618 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported Bracket Modes 0x%x"), suppBracketModes);

   619 	    	CCamera::CCameraAdvancedSettings::TBracketMode defaultBracketMode = CCamera::CCameraAdvancedSettings::EBracketModeOff;

   620 	    	settings->SetBracketMode(defaultBracketMode);

   622 	        CheckNotification(iInputEventUid, result);

   624 	    	CCamera::CCameraAdvancedSettings::TBracketMode retrievedBracketMode = settings->BracketMode() ;

   625 	    	if (defaultBracketMode != retrievedBracketMode)

   626 	    		{

   627 		    	INFO_PRINTF3(_L("CCameraAdvancedSettings Drive Mode  0x%x is not as expected 0x%x"),

   628 	    					defaultBracketMode, retrievedBracketMode);

   629 	    		result = EFail;

   630 	    		}

   633 			// Supported AF assistant light. Set and Get AF assistant light.

   634 			iInputEventUid = KUidECamEventCameraSettingAFAssistantLight;

   635 	    	TInt suppAFAssistantLights =0;

   637 	    	settings->GetSupportedAFAssistantLightL(suppAFAssistantLights);

   639 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported AF Assistant Lights 0x%x"), suppAFAssistantLights);

   640 	    	CCamera::CCameraAdvancedSettings::TAFAssistantLight defaultAFAssistantLight = CCamera::CCameraAdvancedSettings::EAFAssistantLightOff;

   641 	    	settings->SetAFAssistantLightL(defaultAFAssistantLight);

   643 	        CheckNotification(iInputEventUid, result);

   645 	    	CCamera::CCameraAdvancedSettings::TAFAssistantLight retrievedAFAssistantLight;

   646 	    	settings->GetAFAssistantLightL(retrievedAFAssistantLight);

   648 	    	if (defaultAFAssistantLight != retrievedAFAssistantLight)

   649 	    		{

   650 		    	INFO_PRINTF3(_L("CCameraAdvancedSettings AF Assistant Light  0x%x is not as expected 0x%x"),

   651 	    					retrievedAFAssistantLight, defaultAFAssistantLight);

   652 	    		result = EFail;

   653 	    		}

   655 	    	TInt preCaptureWarningSupported = KAllPreCaptureWarnings; // ( = 0x3FFF)

   656 	    	settings->GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::EModeIdle, preCaptureWarningSupported);

   658 	    	// subscribe for pre capture warnings. Poll for it. Unsubscribe for Pre capture warning.

   659 	    	settings->SubscribeToPreCaptureWarningL(preCaptureWarningSupported);

   661 	    	//Poll to know the status of every possible warning ...

   662 	    	TInt warningStatus =0;

   663 	    	settings->GetPreCaptureWarningL(warningStatus);

   665 	    	settings->UnSubscribePreCaptureWarningL();

   667 	    	//set reference screen

   668 	    	iInputEventUid = KUidECamEventCameraSettingReferenceScreen;

   670 	    	CWsScreenDevice* screenDevice = NULL;

   671 	    	// prepare the screen targetted.

   673 	    	settings->SetReferenceScreenL(*screenDevice);

   675 	        CheckNotification(iInputEventUid, result);

   678 		   INFO_PRINTF1(_L("API exercise"));

   679 		   // API exercise

   680 	       TBool lock = ETrue;

   681 	       TInt value = KValue;

   682 	       settings->SetApertureExposureLockOn(lock);

   683 	       settings->ApertureExposureLockOn();

   685 	       	// Automatic selection

   686 	       	settings->SetAutomaticSizeSelectionChangeOn(EFalse);

   687 	       	settings->AutomaticSizeSelectionChangeOn();

   689 			// stabilization mode

   690 			// settings

   691 			settings->SupportedStabilizationModes();

   692 			settings->StabilizationMode();

   693 			settings->SetStabilizationMode(CCamera::CCameraAdvancedSettings::EStabilizationModeVertical);

   695 			settings->SupportedBracketParameters();

   696 			settings->BracketParameter();

   697 			settings->SetBracketParameter(CCamera::CCameraAdvancedSettings::BracketParameterAutoFocus);

   698 			settings->SupportedBracketSteps();

   699 			settings->BracketStep();

   700 			settings->SetBracketStep(CCamera::CCameraAdvancedSettings::EBracketStepMedium);

   702 			TInt startIndex;

   703 			TInt frames;

   705 			settings->GetBracketMerge(startIndex, frames);

   706 			settings->SetBracketMerge(startIndex, frames);

   708 			settings->SupportedFlashModes();

   709 			settings->FlashMode();

   710 			settings->SetFlashMode(CCamera::EFlashSlowRearSync);

   711 			settings->RedEyeReduceOn();

   712 			settings->SetRedEyeReduceOn(EFalse);

   714 			RArray<TInt> steps;

   715 			TValueInfo info;

   717 			settings->GetFlashCompensationStepsL(steps, info);

   718 			TInt flashCompensationStep1 = settings->FlashCompensationStep();

   719 			if(flashCompensationStep1 != KFlashCompensationStep)

   720 				{

   721 				INFO_PRINTF2(_L("old method for FlashCompensationStep retrieving wrong value %d"),flashCompensationStep1);

   722 				result = EFail;

   723 				}

   725 			TInt flashCompensationStep2 = 0;

   726 			TInt err = settings->GetFlashCompensationStep(flashCompensationStep2);

   727 			if(flashCompensationStep1 != flashCompensationStep2)

   728 				{

   729 				INFO_PRINTF1(_L("old and new method for FlashCompensationStep retrieving wrong/dissimilar values"));

   730 				result = EFail;

   731 				}

   732 			if(err)

   733 				{

   734 				INFO_PRINTF2(_L("new method for FlashCompensationStep had error %d"),err);

   735 				result = EFail;

   736 				}

   738 			settings->SetFlashCompensationStep(value);

   739 			TRAP(error, settings->GetCurrentFocusModeStepsL(steps, info));

   741 			TInt negValue;

   742 			TInt posValue;

   743 			TBool ready = ETrue;

   745 			settings->GetFlashCompensationRangeInSteps(negValue, posValue);

   746 			TInt flashCompensation1 = settings->FlashCompensation();

   747 			if(flashCompensation1 != KFlashCompensationInSteps)

   748 				{

   749 				INFO_PRINTF2(_L("old method for FlashCompensation retrieving wrong value %d"),flashCompensation1);

   750 				result = EFail;

   751 				}

   752 			TInt flashCompensation2 = 0;

   753 			err = settings->GetFlashCompensation(flashCompensation2);

   755 			if(flashCompensation1 != flashCompensation2)

   756 				{

   757 				INFO_PRINTF1(_L("old and new method for FlashCompensation retrieving wrong/dissimilar values"));

   758 				result = EFail;

   759 				}

   760 			if(err)

   761 				{

   762 				INFO_PRINTF2(_L("new method for FlashCompensation had error %d"),err);

   763 				result = EFail;

   764 				}

   766 			settings->SetFlashCompensation(value);

   768 			settings->IsFlashReady(ready);

   769 			if(ready != EFalse) // The value the pugin has been set to return

   770 				{

   771 				result = EFail;

   772 				}

   773 			settings->IsExternalFlashPresent();

   774 			settings->GetManualFlashPowerLevelsL(steps, info);

   775 			settings->SetManualFlashPowerLevel(value);

   776 			settings->ManualFlashPowerLevel();

   778 			settings->SupportedExposureModes();

   779 			settings->ExposureMode();

   780 			settings->SetExposureMode(CCamera::EExposureAuto);

   782  			settings->GetExposureCompensationStepsL(steps, info);

   783  			TInt expCompensationStep1 = settings->ExposureCompensationStep();

   784  			if(expCompensationStep1 != KExposureCompensationStep)

   785 				{

   786 				INFO_PRINTF2(_L("old method for ExposureCompensationStep retrieving wrong value %d"),expCompensationStep1);

   787 				result = EFail;

   788 				}

   790 			TInt expCompensationStep2 = 0;

   791 			err = settings->GetExposureCompensationStep(expCompensationStep2);

   792 			if(expCompensationStep1 != expCompensationStep2)

   793 				{

   794 				INFO_PRINTF1(_L("old and new method for ExposureCompensationStep retrieving wrong/dissimilar values"));

   795 				result = EFail;

   796 				}

   797 			if(err)

   798 				{

   799 				INFO_PRINTF2(_L("new method for ExposureCompensationStep had error %d"),err);

   800 				result = EFail;

   801 				}

   802 			settings->SetExposureCompensationStep(value);

   804 			settings->GetExposureCompensationRangeInSteps(negValue, posValue);

   805 			TInt expCompensation1 = settings->ExposureCompensation();

   806 			if(expCompensation1 != KExposureCompensationInSteps)

   807 				{

   808 				INFO_PRINTF2(_L("old method for ExposureCompensation retrieving wrong value %d"),expCompensation1);

   809 				result = EFail;

   810 				}

   812 			TInt expCompensation2 = 0;

   813 			err = settings->GetExposureCompensation(expCompensation2);

   815 			if(expCompensation1 != expCompensation2)

   816 				{

   817 				INFO_PRINTF1(_L("old and new method for ExposureCompensation retrieving wrong/dissimilar values"));

   818 				result = EFail;

   819 				}

   820 			if(err)

   821 				{

   822 				INFO_PRINTF2(_L("new method for ExposureCompensation had error %d"),err);

   823 				result = EFail;

   824 				}

   825 			settings->SetExposureCompensation(value);

   827 			settings->SupportedWhiteBalanceModes();

   828 			settings->WhiteBalanceMode();

   829 			settings->SetWhiteBalanceMode(CCamera::EWBAuto);

   831 			settings->ShootClickOn();

   832 			settings->SetShootClickOn(EFalse);

   833 			settings->GetTimerIntervalsL(steps, info);

   834 			settings->TimerInterval();

   835 			settings->SetTimerInterval(value);

   837 			TTime start;

   838 			TTime end;

   839 			TTime interval;

   841 			settings->GetTimeLapsePeriodRange(start, end);

   842 			settings->GetTimeLapse(start, end, interval);

   843 			settings->SetTimeLapse(start, end, interval);

   845 			settings->PictureOrientation();

   846 			settings->SetPictureOrientation(CCamera::CCameraAdvancedSettings::EPictureOrientationPortrait);

   848 			settings->SupportedPixelAspectRatios();

   849 			settings->PixelAspectRatio();

   850 			settings->SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::EPixelAspect1To1);

   851 			settings->SupportedYuvRanges();

   852 			settings->YuvRange();

   853 			settings->SetYuvRange(CCamera::CCameraAdvancedSettings::EYuvRangeVideoCropped);

   854 			settings->BurstImages();

   855 			settings->SetBurstImages(value);

   856 			settings->GetOpticalZoomStepsL(steps, info);

   857 			settings->OpticalZoom();

   858 			settings->SetOpticalZoom(value);

   859 			settings->GetDigitalZoomStepsL(steps, info);

   860 			settings->DigitalZoom();

   861 			settings->SetDigitalZoom(value);

   863 			TInt sizeIndex =0;

   864 			TBool isInfluencePossible;

   865 			CCamera::TFormat format = CCamera::EFormatYUV420Planar;

   866 			settings->GetDigitalZoomStepsForStillL(steps, info, sizeIndex, format, isInfluencePossible);

   867 			settings->DigitalZoom();

   868 			settings->SetDigitalZoom(value);

   870 			TInt frameRateIndex =0;

   871 			CCamera::TExposure exposure = CCamera::EExposureAuto;

   872 			settings->GetDigitalZoomStepsForVideoL(steps, info, frameRateIndex, sizeIndex, format, isInfluencePossible, exposure);

   873 			settings->DigitalZoom();

   874 			settings->SetDigitalZoom(value);

   876 			settings->ExposureLockOn();

   877 			settings->SetExposureLockOn(EFalse);

   878 			settings->AutoFocusLockOn();

   879 			settings->SetAutoFocusLockOn(EFalse);

   881 			// timeouts

   882 			RArray<TInt> timeouts;

   883     		settings->GetSupportedContinuousAutoFocusTimeoutsL(timeouts, info);

   884     		timeouts.Close();

   885     		settings->ContinuousAutoFocusTimeout();

   886     		settings->SetContinuousAutoFocusTimeout(KContinuousAutoFocusTimeoutValue1);

   888     		// stabilization effects

   889 	        settings->SupportedStabilizationEffects();

   890     		settings->SetStabilizationEffect(CCamera::CCameraAdvancedSettings::EStabilizationAuto);

   891 			CCamera::CCameraAdvancedSettings::TStabilizationEffect effect = settings->StabilizationEffect();

   893 	        // stabilization complexity

   894 			settings->SupportedStabilizationComplexityValues();

   895 			CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity complexity = settings->StabilizationComplexity();

   896 			settings->SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::EStabilizationComplexityAuto);

   898             // ISO rate type

   899 	    	iInputEventUid = KUidECamEventCameraSettingIsoRateType;

   901 			supportedISORateTypes = 0;

   902 			settings->GetSupportedISORateTypeL(supportedISORateTypes);

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

   906 			//List of supported ISO rates can be found using OLD API.

   907 			RArray<TInt> supportedIsoRates;

   908 			settings->GetSupportedIsoRatesL(supportedIsoRates);

   910 			//set to manual ISO rate

   911 			isoRateType = CCamera::CCameraAdvancedSettings::EISOManual;

   912 			if(isoRateType & supportedISORateTypes)

   913 				{

   914 				INFO_PRINTF1(_L("Testing new ISO API for CCamera::CCameraAdvancedSettings::EISOManual"));

   915 				TestISOTypesL(settings, isoRateType, supportedIsoRates, result);

   916 				}

   918 			//switch to unprioritised type of Auto ISO...

   919 			isoRateType = CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised;

   920 			if(isoRateType & supportedISORateTypes)

   921 				{

   922 				INFO_PRINTF1(_L("Testing new ISO API for CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised"));

   923 				TestISOTypesL(settings, isoRateType, supportedIsoRates, result);

   924 				}

   926 			//switch to ISO prioritised AutoISO ...

   927 			isoRateType = CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised;

   928 			if(isoRateType & supportedISORateTypes)

   929 				{

   930 				INFO_PRINTF1(_L("Testing new ISO API for CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised"));

   931 				TestISOTypesL(settings, isoRateType, supportedIsoRates, result);

   932 				}

   934 			//switch to shutter speed prioritised AutoISO...

   935 			isoRateType = CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised;

   936 			if(isoRateType & supportedISORateTypes)

   937 				{

   938 				INFO_PRINTF1(_L("Testing new ISO API for CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised"));

   939 				TestISOTypesL(settings, isoRateType, supportedIsoRates, result);

   940 				}

   942 			//switch to aperture prioritised AutoISO...

   943 			isoRateType = CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised;

   944 			if(isoRateType & supportedISORateTypes)

   945 				{

   946 				INFO_PRINTF1(_L("Testing new ISO API for CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised"));

   947 				TestISOTypesL(settings, isoRateType, supportedIsoRates, result);

   948 				}

   950             supportedIsoRates.Close();

   952             // all functions are called, irrespective of the units; in real case will be one set or the other

   953             TRgb rgb(100,124,130);

   954 		    CCamera::CCameraAdvancedSettings::TWBUnits units = settings->SupportedWBUnits();

   955 		    settings->SetWBRgbValue(rgb);

   956 			settings->GetWBRgbValue(rgb);

   957 			RArray<TInt> temperatures;

   958 			settings->GetWBSupportedColorTemperaturesL(temperatures, info);

   959 			temperatures.Close();

   960 			settings->SetWBColorTemperature(KWBColorTemperature1);

   961 			TInt temp = settings->WBColorTemperature();

   963 			INFO_PRINTF1(_L("GetFocalLengthInfoL method invocation"));

   964 			TInt currentFocalLength=0;

   965 			TInt maxFocalLength=0;

   966 			TRAP(err, settings->GetFocalLengthInfoL(minFocalLength, currentFocalLength, maxFocalLength));

   967 			if(err != KErrNotSupported)

   968 				{

   969 				INFO_PRINTF1(_L("GetFocalLengthInfoL supported!"));

   970 				result = EFail;

   971 				}

   973 			INFO_PRINTF1(_L("GetNumOperationPreferenceL method invocation"));

   974 			TUint numOperationPreferenceSupported=0;

   975 	        TRAP(err, settings->GetNumOperationPreferenceL(numOperationPreferenceSupported));

   976 			if(err != KErrNotSupported)

   977 				{

   978 				INFO_PRINTF1(_L("GetNumOperationPreferenceL supported!"));

   979 				result = EFail;

   980 				}

   982 			INFO_PRINTF1(_L("EnumerateOperationPreferenceL method invocation"));

   984 			TUint operationPreferenceIndex=0;

   985 			CCamera::CCameraAdvancedSettings::TPerformanceLevel speedLevel =

   986 							CCamera::CCameraAdvancedSettings::ELevelDontCare;

   987 			CCamera::CCameraAdvancedSettings::TPerformanceLevel qualityLevel =

   988 							CCamera::CCameraAdvancedSettings::ELevelDontCare;

   989 			CCamera::CCameraAdvancedSettings::TPerformanceLevel lowMemoryConsumptionLevel =

   990 							CCamera::CCameraAdvancedSettings::ELevelDontCare;

   991 			CCamera::CCameraAdvancedSettings::TPerformanceLevel lowPowerConsumptionLevel =

   992 							CCamera::CCameraAdvancedSettings::ELevelDontCare;

   994 	        TRAP(err, settings->EnumerateOperationPreferenceL(operationPreferenceIndex, speedLevel,

   995 	        	qualityLevel, lowMemoryConsumptionLevel, lowPowerConsumptionLevel));

   996 			if(err != KErrNotSupported)

   997 				{

   998 				INFO_PRINTF1(_L("EnumerateOperationPreferenceL supported!"));

   999 				result = EFail;

  1000 				}

  1002 			iInputEventUid = KUidECamEventCameraSettingOperationPreference;

  1003 			settings->SetOperationPreferenceL(operationPreferenceIndex);

  1004 			CheckNotificationNeg(iInputEventUid, result);

  1006 			INFO_PRINTF1(_L("GetOperationPreferenceL method invocation"));

  1007 			TInt opPreferenceIndex;

  1008 			TRAP(err, settings->GetOperationPreferenceL(opPreferenceIndex));

  1009 			if(err != KErrNotSupported)

  1010 				{

  1011 				INFO_PRINTF1(_L("GetOperationPreferenceL supported!"));

  1012 				result = EFail;

  1013 				}

  1015 			INFO_PRINTF1(_L("GetSupportedEventsL method invocation"));

  1016 			RArray<TUid> supportedEvents;

  1017 			settings->GetSupportedEventsL(supportedEvents);

  1019 			if(supportedEvents.Count() != 0)

  1020 				{

  1021 				INFO_PRINTF1(_L("GetSupportedEventsL entry exists!"));

  1022 				result = EFail;

  1023 				}

  1024 			supportedEvents.Close();

  1026 			INFO_PRINTF1(_L("GetIndirectFeatureChangesL method invocation"));

  1027 			RArray<TUid> featureChangesIndirect;

  1028 			TRAP(err, settings->GetIndirectFeatureChangesL(KUidECamEventCameraSettingOperationPreference, featureChangesIndirect));

  1029 			if(err != KErrNone)

  1030 				{

  1031 				INFO_PRINTF1(_L("GetIndirectFeatureChangesL returned error!"));

  1032 				result = EFail;

  1033 				}

  1035 			if(featureChangesIndirect.Count() != 0)

  1036 				{

  1037 				INFO_PRINTF1(_L("GetIndirectFeatureChangesL entry exists!"));

  1038 				result = EFail;

  1039 				}

  1040 			featureChangesIndirect.Close();

  1042 	    	CleanupStack::PopAndDestroy(settings);

  1043 	    	}

  1044 	    else

  1045     		{

  1046     		result = EFail;

  1047     		User::Leave(KErrNoMemory);

  1048     		}

  1049 		CleanupStack::PopAndDestroy(camera);

  1050 		}

  1051 	else

  1052 		{

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

  1054 		result = EFail;

  1055 		User::Leave(KErrNoMemory);

  1056 		}

  1057 	__MM_HEAP_MARKEND;

  1059 	return result;

  1060 	}

  1063 void RECamAdvSetDefaultsTest::TestISOTypesL(CCamera::CCameraAdvancedSettings* aSettings, CCamera::CCameraAdvancedSettings::TISORateType aIsoRateType, RArray<TInt> aSupportedIsoRates, TVerdict& aResult)

  1064 	{

  1065 	TInt param =0;

  1067 	switch(aIsoRateType)

  1068 		{

  1069 		case CCamera::CCameraAdvancedSettings::EISOManual:

  1070 			{

  1071 			param = KDefaultIsoRating;

  1072 			break;

  1073 			}

  1075 		case CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised:

  1076 			{

  1077 			param = KIsoRate01;// ISO rate equal to or closest to (and less than) it should be selected by the

  1078 							  // camera in order to get optimum exposure.

  1079 			break;

  1080 			}

  1082 		case CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised:

  1083 			{

  1084 			param = KShutterSpeed;// Shutter speed equal to or closest to (and faster than) it should be selected by the

  1085 								  // camera in order to get optimum exposure.

  1086 			break;

  1087 			}

  1089 		case CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised:

  1090 			{

  1091 			param = KDefaultAperture;// Aperture opening equal to or closest to (and wider than) it should be selected by the

  1092 								   	 // camera in order to get optimum exposure.

  1093 			break;

  1094 			}

  1096 		default:

  1097 			{

  1098 			param =0;

  1099 			}

  1100 		}

  1102 	aSettings->SetISORateL(aIsoRateType, param);

  1104 	CheckNotification(iInputEventUid, aResult);

  1106 	CCamera::CCameraAdvancedSettings::TISORateType retrievedIsoRateType;

  1107 	TInt retrievedParam =0;

  1108 	TInt retrievedIsoRate =0;

  1110 	aSettings->GetISORateL(retrievedIsoRateType, retrievedParam, retrievedIsoRate);

  1112 	if(retrievedIsoRateType != aIsoRateType)

  1113 		{

  1114 		INFO_PRINTF3(_L("CCameraAdvancedSettings Iso Rate Type 0x%x is not as expected 0x%x"),

  1115 				retrievedIsoRateType, aIsoRateType);

  1116 		aResult = EFail;

  1117 		}

  1119 	if(aIsoRateType & KAutoISOTypes)

  1120 		{

  1121 		if(retrievedParam != param)

  1122 			{

  1123 			INFO_PRINTF3(_L("CCameraAdvancedSettings Auto ISO parameter %d is not as expected %d"),

  1124 					retrievedParam, param);

  1125 			aResult = EFail;

  1126 			}

  1128 		if(retrievedIsoRate == KErrNotFound)

  1129 			{

  1130 			INFO_PRINTF2(_L("CCameraAdvancedSettings retrieved Iso Rate: %d :- Camera incapable of getting ISO under Auto ISO"),

  1131 					retrievedIsoRate);

  1132 			}

  1133 		else

  1134 			{//ISO set under Auto ISO has to be one of supported ISO rates .

  1135 			if (aSupportedIsoRates.Find(retrievedIsoRate) == KErrNotFound)

  1136 				{

  1137 				INFO_PRINTF2(_L("CCameraAdvancedSettings Iso Rate %d is not among the supported ISO rates"),

  1138 						retrievedIsoRate);

  1139 				aResult = EFail;

  1140 				}

  1143 			if(aIsoRateType == CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised)

  1144 				{

  1145 				//ISO rate set should be less than or equal to param

  1146 				if (retrievedIsoRate > param)

  1147 					{

  1148 					INFO_PRINTF3(_L("CCameraAdvancedSettings Iso Rate %d is greater than %d"),

  1149 	    					retrievedIsoRate, param);

  1150 	    			aResult = EFail;

  1151 					}

  1152 				}

  1154 			//use of old API

  1155 			TInt retrievedIsoRateOld = aSettings->IsoRate();

  1156 			if (retrievedIsoRateOld != retrievedIsoRate)

  1157 				{

  1158 				INFO_PRINTF3(_L("CCameraAdvancedSettings OLD and NEW API inconsistent: Iso Rate old %d ; ISO Rate new: %d"),

  1159 						retrievedIsoRateOld, retrievedIsoRate);

  1160 				aResult = EFail;

  1161 				}

  1162 			}

  1164 		//switch to manual ISO using OLD API

  1165 		aSettings->SetIsoRate(KDefaultIsoRating);

  1167 		aSettings->GetISORateL(retrievedIsoRateType, param, retrievedIsoRate);

  1169 		if(retrievedIsoRateType != CCamera::CCameraAdvancedSettings::EISOManual)

  1170 			{

  1171 			INFO_PRINTF3(_L("CCameraAdvancedSettings Iso Rate Type 0x%x is not as expected 0x%x : OLD and NEW API inconsistent"),

  1172 					retrievedIsoRateType, CCamera::CCameraAdvancedSettings::EISOManual);

  1173 			aResult = EFail;

  1174 			}

  1176 		if (retrievedIsoRate != KDefaultIsoRating)

  1177 			{

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

  1179 					retrievedIsoRate, KDefaultIsoRating);

  1180 			aResult = EFail;

  1181 			}

  1182 		}

  1184 	//use of old API

  1185 	TInt retrievedIsoRateOld = aSettings->IsoRate();

  1186 	if (retrievedIsoRateOld != retrievedIsoRate)

  1187 		{

  1188 		INFO_PRINTF3(_L("CCameraAdvancedSettings OLD and NEW API inconsistent: Iso Rate old %d ; ISO Rate new: %d"),

  1189 				retrievedIsoRateOld, retrievedIsoRate);

  1190 		aResult = EFail;

  1191 		}

  1192 	}

  1194 //

  1195 // RECamAdvSetGettersTest //

  1196 //

  1197 RECamAdvSetGettersTest* RECamAdvSetGettersTest::NewL(TBool aAllocTest)

  1198 	{

  1199 	RECamAdvSetGettersTest* self = new (ELeave) RECamAdvSetGettersTest(aAllocTest);

  1200 	return self;

  1201 	}

  1203 RECamAdvSetGettersTest::RECamAdvSetGettersTest(TBool /*aAllocTest*/)

  1204 	{

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

  1206 	}

  1208 TVerdict RECamAdvSetGettersTest::DoTestStepL()

  1209 	{

  1210 	TVerdict result = EPass;

  1211 	CCamera* camera = NULL;

  1213 	TInt error = KErrNone;

  1214 	CCamera::CCameraAdvancedSettings* settings = NULL;

  1216 	__MM_HEAP_MARK;

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

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

  1220 	if (error==KErrNone)

  1221 		{

  1222 		CleanupStack::PushL(camera);

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

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

  1225 	    if (settings!= NULL)

  1226 	    	{

  1227 	    	CleanupStack::PushL(settings);

  1229      	    iInputEventUid = KUidECamEventCameraSettingIsoRate;

  1230 	    	TInt isoRateSet = KIsoRate01;

  1231 	    	settings->SetIsoRate(isoRateSet);

  1232 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings Iso Rate set %d"), isoRateSet);

  1234 	        CheckNotification(iInputEventUid, result);

  1236 			// Get ISO rate. It should have changed to set value.

  1237 	    	TInt isoRate = settings->IsoRate();

  1238 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings get Iso Rate %d"), isoRate);

  1240 	    	if (isoRateSet!=isoRate)

  1241 	    		{

  1242 	    		INFO_PRINTF1(_L("Got a different iso rate than it was set"));

  1243 	    		result = EFail;

  1244 	    		}

  1246 	    	CleanupStack::PopAndDestroy(settings);

  1247 	    	}

  1248 	    else

  1249     		{

  1250     		result = EFail;

  1251     		}

  1252 		CleanupStack::PopAndDestroy(camera);

  1253 		}

  1254 	else

  1255 		{

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

  1257 		result = EFail;

  1258 		}

  1259 	__MM_HEAP_MARKEND;

  1261 	return result;

  1262 	}

  1265 //

  1266 // RECamAdvSetTwoCamTest //

  1267 //

  1268 RECamAdvSetTwoCamTest* RECamAdvSetTwoCamTest::NewL(TBool aAllocTest)

  1269 	{

  1270 	RECamAdvSetTwoCamTest* self = new (ELeave) RECamAdvSetTwoCamTest(aAllocTest);

  1271 	return self;

  1272 	}

  1274 RECamAdvSetTwoCamTest::RECamAdvSetTwoCamTest(TBool /*aAllocTest*/)

  1275 	{

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

  1277 	}

  1279 TVerdict RECamAdvSetTwoCamTest::DoTestStepL()

  1280 	{

  1281 	TVerdict result = EPass;

  1282 	CCamera* camera1 = NULL;

  1283 	CCamera* camera2 = NULL;

  1285 	TInt error = KErrNone;

  1286 	CCamera::CCameraAdvancedSettings* settings1 = NULL;

  1287 	CCamera::CCameraAdvancedSettings* settings2 = NULL;

  1289 	// using observer 2 if exist

  1290 	MCameraObserver2* observer2 = NULL;

  1292 	__MM_HEAP_MARK;

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

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

  1295 	if (error==KErrNone)

  1296 		{

  1297 		CleanupStack::PushL(camera1);

  1298 		TRAP(error, camera2 = CCamera::New2L(*observer2, 1,0));

  1300 		if (error==KErrNone)

  1301 			{

  1302 			CleanupStack::PushL(camera2);

  1303 		    //Second camera

  1304 			settings1 = static_cast<CCamera::CCameraAdvancedSettings*> (camera1->CustomInterface(KECamAdvancedSettingUid));

  1305 	    	RArray<TUid> aSuppSettings1;

  1306 	    	RArray<TUid> aActSettings1;

  1307 	    	if (settings1!= NULL)

  1308 		    	{

  1309 		    	CleanupStack::PushL(settings1);

  1311 				CleanupClosePushL(aSuppSettings1);

  1312 				aSuppSettings1.Reset();

  1313 			    settings1->GetSupportedSettingsL(aSuppSettings1);

  1314 				CleanupClosePushL(aActSettings1);

  1315 				aActSettings1.Reset();

  1316 			    settings1->GetActiveSettingsL(aActSettings1);

  1317 				if ((aActSettings1.Count())==0)

  1318 					{

  1319 	   				INFO_PRINTF1(_L("Active camera. Non empty array expected"));

  1320 	        		result = EFail;

  1321 					}

  1323 				settings1->GetDisabledSettingsL(aActSettings1);

  1324 				}

  1326 		    //Second camera

  1327 			settings2 = static_cast<CCamera::CCameraAdvancedSettings*> (camera2->CustomInterface(KECamAdvancedSettingUid));

  1328 	    	RArray<TUid> aSuppSettings2;

  1329 	    	RArray<TUid> aActSettings2;

  1330 	    	if (settings2!= NULL)

  1331 		    	{

  1332 		    	CleanupStack::PushL(settings2);

  1334 				CleanupClosePushL(aSuppSettings2);

  1335 				aSuppSettings2.Reset();

  1336 	    		settings2->GetSupportedSettingsL(aSuppSettings2);

  1337 				CleanupClosePushL(aActSettings2);

  1338 				aActSettings2.Reset();

  1339 		    	settings2->GetActiveSettingsL(aActSettings2);

  1340 				if ((aActSettings2.Count())!=0)

  1341 					{

  1342  					INFO_PRINTF1(_L("Empty array expected (non present camera)"));

  1343 	       			result = EFail;

  1344 					}

  1345 				}

  1347 	    	CleanupStack::PopAndDestroy(2, &aSuppSettings2); //aActSettings2

  1348 			CleanupStack::PopAndDestroy(settings2);

  1350 			CleanupStack::PopAndDestroy(2, &aSuppSettings1); //aActSettings1

  1351 			CleanupStack::PopAndDestroy(settings1);

  1353 			CleanupStack::PopAndDestroy(camera2);

  1355 			}

  1356 		else

  1357 			{

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

  1359 			result = EFail;

  1360 			}

  1362 		CleanupStack::PopAndDestroy(camera1);

  1364 		}

  1365 	else

  1366 		{

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

  1368 		result = EFail;

  1369 		}

  1370 	__MM_HEAP_MARKEND;

  1372 	return result;

  1373 	}

  1375 //

  1376 // RECamAdvSetNegTest //

  1377 //

  1379 RECamAdvSetNegTest* RECamAdvSetNegTest::NewL(TBool aAllocTest)

  1380 	{

  1381 	RECamAdvSetNegTest* self = new (ELeave) RECamAdvSetNegTest(aAllocTest);

  1382 	return self;

  1383 	}

  1385 RECamAdvSetNegTest::RECamAdvSetNegTest(TBool /*aAllocTest*/)

  1386 	{

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

  1388 	}

  1390 TVerdict RECamAdvSetNegTest::DoTestStepL()

  1391 	{

  1392 	TVerdict result = EPass;

  1393 	CCamera* camera = NULL;

  1395 	TInt error = KErrNone;

  1396 	CCamera::CCameraAdvancedSettings* settings = NULL;

  1398 	__MM_HEAP_MARK;

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

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

  1402 	if (error==KErrNone)

  1403 		{

  1404 		CleanupStack::PushL(camera);

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

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

  1407 	    if (settings!= NULL)

  1408 	    	{

  1409 	    	CleanupStack::PushL(settings);

  1410 	    	// trying to set a value which is not supported

  1411 	    	// the action would fail to set a new value and the notification will fail

  1412 	    	// thus the current value will be different from the requested value. - double verification

  1413      	    iInputEventUid = KUidECamEventCameraSettingIsoRate;

  1414 	    	TInt isoRateSet = KIsoRate0; // not supported rate

  1415 	    	settings->SetIsoRate(isoRateSet);

  1416 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings Iso Rate set 0x%x"), isoRateSet);

  1418 	        CheckNotificationNeg(iInputEventUid, result);

  1420 			// Get ISO rate. It should have changed to set value.

  1421 	    	TInt isoRate = settings->IsoRate();

  1422 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings get Iso Rate 0x%x"), isoRate);

  1423 	    	if (isoRateSet == isoRate)

  1424 	    		{

  1425 	    		INFO_PRINTF1(_L("Got an unsupported iso rate set"));

  1426 	    		result = EFail;

  1427 	    		}

  1429  			// Check the new API for ISO setting as well.

  1430  			iInputEventUid = KUidECamEventCameraSettingIsoRateType;

  1432 	    	settings->SetISORateL(CCamera::CCameraAdvancedSettings::EISOManual, isoRateSet);

  1433 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings Iso Rate set 0x%x"), isoRateSet);

  1435 	        CheckNotificationNeg(iInputEventUid, result);

  1437 			// Get ISO rate. It should have changed to set value.

  1438 	    	CCamera::CCameraAdvancedSettings::TISORateType isoRateType = CCamera::CCameraAdvancedSettings::EISOManual;

  1439 	    	TInt index =0;

  1440 	    	settings->GetISORateL(isoRateType, index, isoRate);

  1441 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings get Iso Rate 0x%x"), isoRate);

  1442 	    	if (isoRateSet == isoRate)

  1443 	    		{

  1444 	    		INFO_PRINTF1(_L("Got an unsupported iso rate set"));

  1445 	    		result = EFail;

  1446 	    		}

  1448 	    	CleanupStack::PopAndDestroy(settings);

  1449 	    	}

  1450 	    else

  1451     		{

  1452     		result = EFail;

  1453     		}

  1454 		CleanupStack::PopAndDestroy(camera);

  1455 		}

  1456 	else

  1457 		{

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

  1459 		result = EFail;

  1460 		}

  1461 	__MM_HEAP_MARKEND;

  1463 	return result;

  1464 	}

  1466 //

  1467 // RECamAdvSetBaselineTest //

  1468 //

  1469 RECamAdvSetBaselineTest* RECamAdvSetBaselineTest::NewL(TBool aAllocTest)

  1470 	{

  1471 	RECamAdvSetBaselineTest* self = new (ELeave) RECamAdvSetBaselineTest(aAllocTest);

  1472 	return self;

  1473 	}

  1475 RECamAdvSetBaselineTest::RECamAdvSetBaselineTest(TBool)

  1476 	{

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

  1478 	}

  1480 TVerdict RECamAdvSetBaselineTest::DoTestStepL()

  1481 	{

  1482 	TVerdict result = EPass;

  1483 	CCamera* camera = NULL;

  1485 	TInt error = KErrNone;

  1486 	CCamera::CCameraAdvancedSettings* settings = NULL;

  1488 	__MM_HEAP_MARK;

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

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

  1491 	if (error==KErrNone)

  1492 		{

  1493 		CleanupStack::PushL(camera);

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

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

  1496 	    if (settings!= NULL)

  1497 	    	{

  1498 	    	CleanupStack::PushL(settings);

  1500 	    	// Supported Focus Range. Set unfamilar Focus Range. Get a known Focus Range.

  1501 			iInputEventUid = KUidECamEventCameraSettingFocusRange;

  1502 	    	TInt suppFocusRanges = settings->SupportedFocusRanges();

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

  1504 	    	if(suppFocusRanges > KBaselinedFocusRanges)

  1505 	    		{

  1506 	    		INFO_PRINTF1(_L("Unfamiliar focus range received"));

  1507 	    		result = EFail;

  1508 	    		}

  1510 	    	CCamera::CCameraAdvancedSettings::TFocusRange unfamilarFocusRange = CCamera::CCameraAdvancedSettings::EFocusRangeHyperfocal;

  1511 			settings->SetFocusRange(unfamilarFocusRange);

  1513 			// Check for KUidECamEventCameraSettingFocusRange.

  1514 	        CheckNotification(iInputEventUid, result);

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

  1517 	    	if (CCamera::CCameraAdvancedSettings::EFocusRangeAuto != retrievedFocusRange)

  1518 	    		{

  1519 	   		 	INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar/wrong Focus Range"));

  1520 	    		result = EFail;

  1521 	    		}

  1523 	        // Supported White Balance Modes. Set unfamilar White Balance. Get a known White Balance.

  1524 			iInputEventUid = KUidECamEventCameraSettingsWBValue;

  1525 	    	TInt suppWhiteBalance = settings->SupportedWhiteBalanceModes();

  1526 	    	INFO_PRINTF2(_L("CCameraAdvancedSettings supported White Balance 0x%x"), suppWhiteBalance);

  1527 	    	if(suppWhiteBalance > KBaselinedWhiteBalanceModes)

  1528 	    		{

  1529 	    		INFO_PRINTF1(_L("Unfamiliar White Balance received"));

  1530 	    		result = EFail;

  1531 	    		}

  1533 	    	CCamera::TWhiteBalance unfamilarWhiteBalance = CCamera::EWBDaylightUnderWater;

  1534 			settings->SetWhiteBalanceMode(unfamilarWhiteBalance);

  1536 			// Check for KUidECamEventCameraSettingsWBValue.

  1537 	        CheckNotification(iInputEventUid, result);

  1539 	    	CCamera::TWhiteBalance retrievedWhiteBalance = settings->WhiteBalanceMode();

  1540 	    	if (CCamera::EWBAuto != retrievedWhiteBalance)

  1541 	    		{

  1542 	   		 	INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar/wrong WhiteBalance"));

  1543 	    		result = EFail;

  1544 	    		}

  1546 			RArray<TUid> settingsList;

  1547 	    	CleanupClosePushL(settingsList);

  1548 	    	// check for GetSupportedSettings

  1549 	    	settings->GetSupportedSettingsL(settingsList);

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

  1552 	    		{

  1553 	    		if(settingsList[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)

  1554 	    			{

  1555 	    			INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar settings"));

  1556 	    			result = EFail;

  1557 	    			}

  1558 	    		}

  1559 	    	settingsList.Reset();

  1561 	    	// check for GetActiveSettings

  1562 	    	settings->GetActiveSettingsL(settingsList);

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

  1565 	    		{

  1566 	    		if(settingsList[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)

  1567 	    			{

  1568 	    			INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar settings"));

  1569 	    			result = EFail;

  1570 	    			}

  1571 	    		}

  1572 	    	settingsList.Reset();

  1574 	    	// check for GetDisabledSettings

  1575 	    	settings->GetDisabledSettingsL(settingsList);

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

  1578 	    		{

  1579 	    		if(settingsList[index].iUid > KUidECamEventCameraSettingAutoFocusType2UidValue)

  1580 	    			{

  1581 	    			INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar settings"));

  1582 	    			result = EFail;

  1583 	    			}

  1584 	    		}

  1585 	    	settingsList.Reset();

  1587 	    	// check for PRECaptureWarning

  1588 	    	TInt preCaptureWarningSupported = KAllPreCaptureWarnings; // ( = 0x3FFF)

  1589 	    	settings->GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::EModeIdle, preCaptureWarningSupported);

  1590 	    	if(preCaptureWarningSupported != ((CCamera::CCameraAdvancedSettings::EPCWGeneralWarning << 1)-1))

  1591 	    		{

  1592 	    		INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar preCaptureWarningSupported"));

  1593 	    		result = EFail;

  1594 	    		}

  1596 	    	// subscribe for pre capture warnings. Poll for it. Unsubscribe for Pre capture warning.

  1597 	    	settings->SubscribeToPreCaptureWarningL(preCaptureWarningSupported);

  1599 	    	//Poll to know the status of every possible warning ...

  1600 	    	TInt warningStatus = preCaptureWarningSupported;

  1601 	    	settings->GetPreCaptureWarningL(warningStatus);

  1602 	    	if(warningStatus != ((CCamera::CCameraAdvancedSettings::EPCWGeneralWarning << 1)-1))

  1603 	    		{

  1604 	    		INFO_PRINTF1(_L("CCameraAdvancedSettings retrieved unfamilar PreCaptureWarning"));

  1605 	    		result = EFail;

  1606 	    		}

  1608 	    	settings->UnSubscribePreCaptureWarningL();

  1610 			CleanupStack::PopAndDestroy(&settingsList);

  1611 	    	CleanupStack::PopAndDestroy(settings);

  1612 	    	}

  1613 	    else

  1614     		{

  1615     		result = EFail;

  1616     		}

  1617 		CleanupStack::PopAndDestroy(camera);

  1618 		}

  1619 	else

  1620 		{

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

  1622 		result = EFail;

  1623 		}

  1624 	__MM_HEAP_MARKEND;

  1626 	return result;

  1627 	}

  1629 class TDummyObserver: public MCameraObserver2

  1630     {

  1631 public:

  1632     explicit TDummyObserver(TInt& aErrorPointer);

  1634     virtual void HandleEvent(const TECAMEvent& aEvent);

  1635     virtual void ViewFinderReady(MCameraBuffer& aCameraBuffer,TInt aError);

  1636     virtual void ImageBufferReady(MCameraBuffer& aCameraBuffer,TInt aError);

  1637     virtual void VideoBufferReady(MCameraBuffer& aCameraBuffer,TInt aError);

  1639 private:

  1640     TInt& iErrorPointer;

  1641     };

  1643 TDummyObserver::TDummyObserver(TInt& aErrorPointer):iErrorPointer(aErrorPointer)

  1644     {

  1645     }

  1647 void TDummyObserver::HandleEvent(const TECAMEvent& /*aEvent*/)

  1648     {

  1649     return;

  1650     }

  1652 void TDummyObserver::ViewFinderReady(MCameraBuffer& /*aCameraBuffer*/, TInt aError)

  1653     {

  1654     iErrorPointer = aError;

  1655     }

  1657 void TDummyObserver::ImageBufferReady(MCameraBuffer& /*aCameraBuffer*/, TInt aError)

  1658     {

  1659     iErrorPointer = aError;

  1660     }

  1662 void TDummyObserver::VideoBufferReady(MCameraBuffer& /*aCameraBuffer*/,TInt aError)

  1663     {

  1664     iErrorPointer = aError;

  1665     }

  1667 RECamAdvSetTest2* RECamAdvSetTest2::NewL(TBool aAllocTest)

  1668 	{

  1669 	RECamAdvSetTest2* self = new (ELeave) RECamAdvSetTest2(aAllocTest);

  1670 	return self;

  1671 	}

  1673 RECamAdvSetTest2::RECamAdvSetTest2(TBool /*aAllocTest*/)

  1674 	{

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

  1676 	}

  1678 void RECamAdvSetTest2::RatioSubStepL(CCamera::CCameraAdvancedSettings* settings, TInt aSuppRange, TInt aTestValue, TInt aExpValue)

  1679     {

  1680 // Pixel ratio's //

  1681     TInt suppRatios = settings->SupportedPixelAspectRatios();

  1682     if (suppRatios != aSuppRange)

  1683         {

  1684     	INFO_PRINTF2(_L("--Error: Supported pixel ratios are wrong %x "), suppRatios);

  1685     	User::Leave(KErrGeneral);

  1686         }

  1687     settings->SetPixelAspectRatio( CCamera::CCameraAdvancedSettings::TPixelAspectRatio(aTestValue) );

  1689     TInt ratio = settings->PixelAspectRatio();

  1691     if (ratio != aExpValue)

  1692         {

  1693     	INFO_PRINTF2(_L("--Error: Returned ration is wrong %x "), ratio);

  1694     	User::Leave(KErrGeneral);

  1695         }

  1696     }

  1698 void RECamAdvSetTest2::FlashSubStepL(CCamera::CCameraAdvancedSettings* settings, TInt aSuppRange, TInt aTestValue, TInt aExpValue)

  1699     {

  1700 // Flash modes //

  1701     TInt suppFlashModes = settings->SupportedFlashModes();

  1703     if (suppFlashModes != aSuppRange)

  1704         {

  1705     	INFO_PRINTF2(_L("--Error: Supported flash modes are wrong %x "), suppFlashModes);

  1706     	User::Leave(KErrGeneral);

  1707         }

  1708     settings->SetFlashMode( CCamera::TFlash(aTestValue) );

  1710     TInt flashMode = settings->FlashMode();

  1712     if (flashMode != aExpValue)

  1713         {

  1714     	INFO_PRINTF2(_L("--Error: Returned flash mode is wrong %x "), flashMode);

  1715     	User::Leave(KErrGeneral);

  1716         }

  1717     }

  1719 void RECamAdvSetTest2::OvrSubStepL(CCamera& aCamera, TInt aSuppRange, TInt aTestValue, TInt aExpValue)

  1720     {

  1721     // Overlay modes //

  1722     CCamera::CCameraOverlay* overlay = NULL;

  1723     TInt error = KErrNone;

  1724     TRAP(error, overlay = CCamera::CCameraOverlay::NewL(aCamera));

  1726     if (overlay == NULL)

  1727         {

  1728     	INFO_PRINTF1(_L("--Error: Failed to get the CCameraOverlay"));

  1729     	User::Leave(KErrGeneral);

  1730         }

  1731     CleanupStack::PushL(overlay);

  1732     CCamera::CCameraOverlay::TOverlaySupportInfo overlaySupInfo;

  1733     overlay->GetOverlaySupport( overlaySupInfo );

  1735     if (overlaySupInfo.iSupportedModes != aSuppRange)

  1736         {

  1737     	INFO_PRINTF2(_L("--Error: Supported overlay modes are wrong %x "), overlaySupInfo.iSupportedModes);

  1738     	User::Leave(KErrGeneral);

  1739         }

  1741     CCamera::CCameraOverlay::TOverlayParameters ovrParams;

  1742     ovrParams.iCurrentModes = aTestValue;

  1743     ovrParams.iCurrentTypes = CCamera::CCameraOverlay::EPerPixel;

  1745     CFbsBitmap* bmp = new (ELeave) CFbsBitmap();

  1746     CleanupStack::PushL(bmp);

  1747     TUint handle = 0;

  1748     TRAP(error, handle = overlay->CreateOverlayL(ovrParams, bmp) );

  1749     if (error != KErrNone)

  1750         {

  1751     	INFO_PRINTF2(_L("--Error: failed to create overlay %d "), error);

  1752     	User::Leave(KErrGeneral);

  1753         }

  1755     CCamera::CCameraOverlay::TOverlayParameters retrievedParams;

  1756     overlay->GetOverlayParametersL(handle, retrievedParams);

  1757     overlay->ReleaseOverlay(handle);

  1759     if (retrievedParams.iCurrentModes != aExpValue)

  1760         {

  1761     	INFO_PRINTF2(_L("--Error: wrong overlay params retrieved %x "), retrievedParams.iCurrentModes);

  1762     	User::Leave(KErrGeneral);

  1763         }

  1764     CleanupStack::PopAndDestroy(2, overlay);

  1765     }

  1767 TVerdict RECamAdvSetTest2::DoTestStepL()

  1768 	{

  1769 	const TInt KNew2PixRatio    = CCamera::CCameraAdvancedSettings::EEPixelAspect40To33;

  1770 	const TInt KNew2SuppRatios  = ( CCamera::CCameraAdvancedSettings::EEPixelAspect40To33 << 1) - 1;

  1772 	const TInt KOldPixRatio     = CCamera::CCameraAdvancedSettings::EEPixelAspect59To54;

  1773 	const TInt KOldSuppRatios   = ( CCamera::CCameraAdvancedSettings::EEPixelAspect59To54 << 1) - 1;

  1775 	const TInt KNew2FlashModes  = (CCamera::EFlashVideoLight << 1) - 1;

  1776 	const TInt KNew2FlashMode   = CCamera::EFlashVideoLight;

  1778 	const TInt KOldFlashModes   = (CCamera::EFlashManual << 1) - 1;

  1779 	const TInt KOldFlashMode    = CCamera::EFlashManual;

  1781 	const TInt KNew2OvrSuppt    = (CCamera::CCameraOverlay::EModeStillImageBurst << 1) - 1;

  1782 	const TInt KOldOvrSuppt     = (CCamera::CCameraOverlay::EModeVideo << 1) - 1;

  1784 	CCamera* camera = NULL;

  1785 	TInt callbackError = KErrNone;

  1786 	TDummyObserver observer2(callbackError);

  1788 	TInt error = KErrNone;

  1789 	CCamera::CCameraAdvancedSettings* settings = NULL;

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

  1792 	if (error!=KErrNone)

  1793 		{

  1794 		INFO_PRINTF2(_L("--Error creating CCamera object %d"),error);

  1795 		User::Leave(KErrGeneral);

  1796 		}

  1797 	CleanupStack::PushL(camera);

  1799     settings = static_cast<CCamera::CCameraAdvancedSettings*>

  1800 								(camera->CustomInterface(KECamAdvancedSettingUid));

  1801     if (settings == NULL)

  1802     	{

  1803     	INFO_PRINTF1(_L("--Error: Failed to get the CCameraAdvancedSettings"));

  1804     	User::Leave(KErrGeneral);

  1805     	}

  1806     CleanupStack::PushL(settings);

  1808     RatioSubStepL(settings, KNew2SuppRatios, KNew2PixRatio, KNew2PixRatio);

  1809     FlashSubStepL(settings, KNew2FlashModes, KNew2FlashMode, KNew2FlashMode);

  1810     OvrSubStepL(*camera, KNew2OvrSuppt, KNew2OvrSuppt, KNew2OvrSuppt);

  1812     CleanupStack::PopAndDestroy(2, camera);

  1814 // now try to use it as an "old" client //

  1815 	TRAP(error, camera = CCamera::NewL(observer2, 0, 100));

  1816 	if (error!=KErrNone)

  1817 		{

  1818 		INFO_PRINTF2(_L("--Error creating CCamera object %d"),error);

  1819 		User::Leave(KErrGeneral);

  1820 		}

  1821 	CleanupStack::PushL(camera);

  1823     settings = static_cast<CCamera::CCameraAdvancedSettings*>

  1824 								(camera->CustomInterface(KECamAdvancedSettingUid));

  1825     if (settings == NULL)

  1826     	{

  1827     	INFO_PRINTF1(_L("--Error: Failed to get the CCameraAdvancedSettings"));

  1828     	User::Leave(KErrGeneral);

  1829     	}

  1830     CleanupStack::PushL(settings);

  1832     RatioSubStepL(settings, KOldSuppRatios, KOldPixRatio, KOldPixRatio);

  1833     RatioSubStepL(settings, KOldSuppRatios, KNew2PixRatio, CCamera::CCameraAdvancedSettings::EPixelAspectUnknown);

  1835     FlashSubStepL(settings, KOldFlashModes, KOldFlashMode, KOldFlashMode);

  1836     FlashSubStepL(settings, KOldFlashModes, KNew2FlashMode, CCamera::EFlashAuto);

  1838     OvrSubStepL(*camera, KOldOvrSuppt, KOldOvrSuppt, KOldOvrSuppt);

  1839     OvrSubStepL(*camera, KOldOvrSuppt, CCamera::CCameraOverlay::EModeClientViewfinder,

  1840                         CCamera::CCameraOverlay::EModeViewfinder);

  1842     OvrSubStepL(*camera, KOldOvrSuppt, CCamera::CCameraOverlay::EModeStillImageBurst,

  1843                         CCamera::CCameraOverlay::EModeStillImage);

  1845     CleanupStack::PopAndDestroy(2, camera);

  1846 	return EPass;

  1847 	}

  1850 RECamContinuousZoomAllocTest* RECamContinuousZoomAllocTest::NewL(TBool aAllocTest)

  1851 	{

  1852 	RECamContinuousZoomAllocTest* self = new (ELeave) RECamContinuousZoomAllocTest(aAllocTest);

  1853 	return self;

  1854 	}

  1856 RECamContinuousZoomAllocTest::RECamContinuousZoomAllocTest(TBool /*aAllocTest*/)

  1857 	{

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

  1859 	}

  1861 TVerdict RECamContinuousZoomAllocTest::DoTestStepL()

  1862 	{

  1863 	TVerdict verdict = EFail;

  1864 	INFO_PRINTF1(_L("Alloc test"));

  1865 	TInt i;

  1866 	TInt err;

  1867 	for (i = 1 ; ; i++)

  1868 		{

  1869 		__MM_HEAP_MARK;

  1871 		if (i % 5 == 0)

  1872 			{

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

  1874 			}

  1876 		__UHEAP_SETFAIL(RHeap::EFailNext, i);

  1878 		TRAP(err, verdict = DoAllocTestStepL());

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

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

  1882 		User::Free(testAlloc);

  1884 		__UHEAP_RESET;

  1885 		__MM_HEAP_MARKEND;

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

  1888 			{

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

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

  1891 			verdict = EPass;

  1892 			break;

  1893 			}

  1894 		}

  1895 	return verdict;

  1896 	}

  1898 TVerdict RECamContinuousZoomAllocTest::DoAllocTestStepL()

  1899 	{

  1900 	TVerdict result = EPass;

  1901 	CCamera* camera = NULL;

  1903 	TInt error = KErrNone;

  1904 	CCamera::CCameraAdvancedSettings* settings = NULL;

  1905 	CCamera::CCameraContinuousZoom* zoom = NULL;

  1907 	// using observer 2 if exist

  1908 	MCameraObserver2* observer2 = NULL;

  1910 	__MM_HEAP_MARK;

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

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

  1913 	if (error==KErrNone)

  1914 		{

  1915 		CleanupStack::PushL(camera);

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

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

  1918 	    if (settings!= NULL)

  1919 	    	{

  1920 	    	CleanupStack::PushL(settings);

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

  1922 	    	CCamera::CCameraAdvancedSettings::TContinuousZoomType continuousZoomType =

  1923 	    		 		CCamera::CCameraAdvancedSettings::EContinuousZoomMixed;

  1925 	    	INFO_PRINTF1(_L("Create continuous zoom from advanced settings object"));

  1926 	    	TRAP(error, settings->CreateContinuousZoomL(*this, continuousZoomType, zoom));

  1927 	    	if (error == KErrNone)

  1928 	    		{

  1929 	    		CleanupStack::PushL(zoom);

  1930 	    		}

  1931 	    	else

  1932 	    		{

  1933 	    		ERR_PRINTF2(_L("Unexpected %d return from CCamera::CreateContinuousZoomL()"), error);

  1934 	    		result = EFail;

  1935 	    		User::Leave(KErrNoMemory);

  1936 	    		}

  1937 	    	}

  1938 	    else

  1939     		{

  1940     		ERR_PRINTF1(_L("Could not create CCameraAdvancedSettings"));

  1941     		result = EFail;

  1942     		User::Leave(KErrNoMemory);

  1943     		}

  1944 		}

  1945 	else

  1946 		{

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

  1948 		result = EFail;

  1949 		User::Leave(KErrNoMemory);

  1950 		}

  1952 	CleanupStack::PopAndDestroy(3, camera);

  1953 	__MM_HEAP_MARKEND;

  1955 	// create a settings object using New2L

  1956 	__MM_HEAP_MARK;

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

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

  1961 	if (error==KErrNone)

  1962 		{

  1963 		CleanupStack::PushL(camera);

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

  1965 		if (error==KErrNone)

  1966 	    	{

  1967 	    	CleanupStack::PushL(settings);

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

  1969 	    	CCamera::CCameraAdvancedSettings::TContinuousZoomType continuousZoomType =

  1970 	    		 		CCamera::CCameraAdvancedSettings::EContinuousZoomMixed;

  1972 	    	INFO_PRINTF1(_L("Create continuous zoom from advanced settings object"));

  1973 	    	TRAP(error, settings->CreateContinuousZoomL(*this, continuousZoomType, zoom));

  1974 	    	if (error == KErrNone)

  1975 	    		{

  1976 	    		CleanupStack::PushL(zoom);

  1977 	    		}

  1978 	    	else

  1979 	    		{

  1980 	    		ERR_PRINTF2(_L("Unexpected %d return from CCamera::CreateContinuousZoomL()"), error);

  1981 	    		result = EFail;

  1982 	    		User::Leave(KErrNoMemory);

  1983 	    		}

  1984 	    	}

  1985 	    else

  1986     		{

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

  1988     		result = EFail;

  1989     		User::Leave(KErrNoMemory);

  1990     		}

  1991 		}

  1992 	else

  1993 		{

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

  1995 		result = EFail;

  1996 		User::Leave(KErrNoMemory);

  1997 		}

  1999 	CleanupStack::PopAndDestroy(3, camera);

  2000 	__MM_HEAP_MARKEND;

  2001 	return result;

  2002 	}

  2004 RECamContinuousZoomTest* RECamContinuousZoomTest::NewL(TBool aAllocTest)

  2005 	{

  2006 	RECamContinuousZoomTest* self = new (ELeave) RECamContinuousZoomTest(aAllocTest);

  2007 	return self;

  2008 	}

  2010 RECamContinuousZoomTest::RECamContinuousZoomTest(TBool /*aAllocTest*/)

  2011 	{

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

  2013 	}

  2015 TVerdict RECamContinuousZoomTest::DoTestStepL()

  2016 	{

  2017 	__MM_HEAP_MARK;

  2018 	TVerdict result = EPass;

  2019 	CCamera* camera = NULL;

  2020 	TInt callbackError = KErrNone;

  2021 	TDummyObserver observer2(callbackError);

  2023 	CCamera::CCameraAdvancedSettings* settings = NULL;

  2025 	camera = CCamera::New2L(observer2, 0, 0);

  2026 	CleanupStack::PushL(camera);

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

  2029     if (settings == NULL)

  2030     	{

  2031     	ERR_PRINTF1(_L("--Error: Failed to get the CCameraAdvancedSettings"));

  2032     	User::Leave(KErrGeneral);

  2033     	}

  2034     CleanupStack::PushL(settings);

  2036 	TUint supportedContinuousZoomType = 100;

  2037 	settings->GetSupportedContinuousZoomTypeL(supportedContinuousZoomType);

  2038 	if(supportedContinuousZoomType != 0)

  2039 		{

  2040 		ERR_PRINTF1(_L("GetSupportedContinuousZoomTypeL supported!"));

  2041 		result = EFail;

  2042 		CleanupStack::PopAndDestroy(2, camera);

  2043 		return result;

  2044 		}

  2046 	CCamera::CCameraAdvancedSettings::TContinuousZoomType continuousZoomType =

  2047 		 		CCamera::CCameraAdvancedSettings::EContinuousZoomMixed;

  2049 	CCamera::CCameraContinuousZoom* continuousZoom = NULL;

  2050 	settings->CreateContinuousZoomL(*this, continuousZoomType, continuousZoom);

  2051 	CleanupStack::PushL(continuousZoom);

  2053 	CCamera::CCameraAdvancedSettings::TContinuousZoomSupportInfo info;

  2054 	continuousZoom->GetContinuousZoomSupportInfoL(info);

  2056 	INFO_PRINTF1(_L("Fake supported continuous zoom settings are:"));

  2057 	INFO_PRINTF2(_L("Max speed supported = %d"), info.iMaxSpeedSupported);

  2058 	INFO_PRINTF2(_L("Min acceleration supported = %d"), info.iMinAccelerationSupported);

  2059 	INFO_PRINTF2(_L("Max acceleration supported = %d"), info.iMaxAccelerationSupported);

  2060 	INFO_PRINTF2(_L("Min continuous zoom limit = %d"), info.iContinuousZoomMinLimit);

  2061 	INFO_PRINTF2(_L("Max continuous zoom limit = %d"), info.iContinuousZoomMaxLimit);

  2063 	CCamera::CCameraAdvancedSettings::TContinuousZoomParameters param;

  2064 	param.iContinuousZoomType = continuousZoomType;

  2065 	param.iContinuousZoomAcceleration = 0;

  2066 	param.iContinuousZoomSpeed = 1;

  2067 	param.iContinuousZoomLimit = 5;

  2068 	param.iZoomDirection = CCamera::CCameraAdvancedSettings::EZoomDirectionWide;

  2070 	INFO_PRINTF1(_L("Calling StartContinuousZoomL()"));

  2071 	continuousZoom->StartContinuousZoomL(param);

  2073 	INFO_PRINTF1(_L("Calling StopContinuousZoomL()"));

  2074 	continuousZoom->StopContinuousZoom();

  2076 	INFO_PRINTF1(_L("Creating second continuous zoom object and comparing unique zoom ids"));

  2077 	TInt id = 0;

  2078 	TInt secondId = 0;

  2079 	continuousZoom->GetContinuousZoomId(id);

  2081 	CCamera::CCameraContinuousZoom* secondContinuousZoom = NULL;

  2082 	settings->CreateContinuousZoomL(*this, continuousZoomType, secondContinuousZoom);

  2083 	secondContinuousZoom->GetContinuousZoomId(secondId);

  2085 	INFO_PRINTF2(_L("Zoom Id of first object is %d"), id);

  2086 	INFO_PRINTF2(_L("Zoom Id of second object is %d"), secondId);

  2087 	if(id == secondId)

  2088 		{

  2089 		ERR_PRINTF1(_L("Zoom ids of both continuous zoom objects are the same"));

  2090 		result = EFail;

  2091 		delete secondContinuousZoom;

  2092 		CleanupStack::PopAndDestroy(3, camera);

  2093 		return result;

  2094 		}

  2095 	delete secondContinuousZoom;

  2097 	INFO_PRINTF1(_L("Attempting to start continuous zoom with 'unsupported' values"));

  2098 	param.iContinuousZoomSpeed = 100;

  2099 	param.iContinuousZoomAcceleration = -10;

  2100 	param.iContinuousZoomLimit = 20;

  2101 	TRAPD(err, continuousZoom->StartContinuousZoomL(param));

  2102 	if(err == KErrArgument)

  2103 		{

  2104 		INFO_PRINTF2(_L("StartContinuousZoom() correctly failed with %d"), err);

  2105 		}

  2106 	else if(err == KErrNone)

  2107 		{

  2108 		ERR_PRINTF1(_L("StartContinuousZoom() succeeded with unsupported values"));

  2109 		result = EFail;

  2110 		}

  2111 	else

  2112 		{

  2113 		ERR_PRINTF2(_L("StartContinuousZoom() failed with unexpected error %d"), err);

  2114 		result = EFail;

  2115 		}

  2117 	CleanupStack::PopAndDestroy(3, camera);

  2118 	__MM_HEAP_MARKEND;

  2119 	return result;

  2120 	}

  2123 RECamDependantSupportedDriveModesTest* RECamDependantSupportedDriveModesTest::NewL(TBool aAllocTest)

  2124 	{

  2125 	RECamDependantSupportedDriveModesTest* self = new (ELeave) RECamDependantSupportedDriveModesTest(aAllocTest);

  2126 	return self;

  2127 	}

  2129 RECamDependantSupportedDriveModesTest::RECamDependantSupportedDriveModesTest(TBool /*aAllocTest*/)

  2130 	{

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

  2132 	}

  2134 TVerdict RECamDependantSupportedDriveModesTest::DoTestStepL()

  2135 	{

  2136 	__MM_HEAP_MARK;

  2137 	TVerdict result = EPass;

  2138 	CCamera* camera = NULL;

  2139 	MCameraObserver* observer = NULL;

  2140 	MCameraObserver2* observer2 = NULL;

  2141 	CCamera::CCameraAdvancedSettings* settings = NULL;

  2143 	INFO_PRINTF1(_L("Testing drive modes returned for legacy CCamera::NewL()"));

  2144 	camera = CCamera::NewL(*observer, 0);

  2145 	CleanupStack::PushL(camera);

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

  2148     if (settings == NULL)

  2149     	{

  2150     	ERR_PRINTF1(_L("--Error: Failed to get the CCameraAdvancedSettings"));

  2151     	User::Leave(KErrGeneral);

  2152     	}

  2153     CleanupStack::PushL(settings);

  2155     CCamera::CCameraAdvancedSettings::TDriveMode driveMode = settings->DriveMode();

  2156     if(driveMode != CCamera::CCameraAdvancedSettings::EDriveModeAuto)

  2157     	{

  2158     	ERR_PRINTF1(_L("Drive mode returned for CCamera::NewL() not CCameraAdvancedSettings::EDriveModeAuto as expected"));

  2159     	result = EFail;

  2160     	return result;

  2161     	}

  2163     TInt supportedDriveModes = settings->SupportedDriveModes();

  2164     if(supportedDriveModes & CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture)

  2165     	{

  2166     	ERR_PRINTF1(_L("Unexpected error - EDriveModeTimeNudgeCapture supported for CCamera::NewL()"));

  2167     	result = EFail;

  2168     	return result;

  2169     	}

  2171     settings->SetDriveMode(CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture);

  2172     driveMode = settings->DriveMode();

  2173     if(driveMode == CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture)

  2174     	{

  2175     	ERR_PRINTF1(_L("Unexpected error - drive mode is EDriveModeTimeNudgeCapture for CCamera::NewL()"));

  2176     	result = EFail;

  2177     	return result;

  2178     	}

  2179     else

  2180     	{

  2181     	INFO_PRINTF1(_L("Supported drive modes do not include new EDriveTimeNudgeCapture - expected for CCamera::NewL()"));

  2182     	}

  2183     CleanupStack::PopAndDestroy(2, camera);

  2187     INFO_PRINTF1(_L("Now testing drive modes returned for CCamera::New2L()"));

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

  2189 	CleanupStack::PushL(camera);

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

  2192     if (settings == NULL)

  2193     	{

  2194     	ERR_PRINTF1(_L("--Error: Failed to get the CCameraAdvancedSettings"));

  2195     	User::Leave(KErrGeneral);

  2196     	}

  2197     CleanupStack::PushL(settings);

  2199     supportedDriveModes = settings->SupportedDriveModes();

  2200     settings->SetDriveMode(CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture);

  2201     driveMode = settings->DriveMode();

  2202     CleanupStack::PopAndDestroy(2, camera);

  2204     if(!(supportedDriveModes & CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture))

  2205     	{

  2206     	ERR_PRINTF1(_L("Unexpected error - EDriveModeTimeNudgeCapture not supported for CCamera::New2L()"));

  2207     	result = EFail;

  2208     	return result;

  2209     	}

  2210     else if(driveMode != CCamera::CCameraAdvancedSettings::EDriveModeTimeNudgeCapture)

  2211     	{

  2212     	ERR_PRINTF1(_L("Unexpected error - drive mode is not EDriveModeTimeNudgeCapture for CCamera::New2L()"));

  2213     	result = EFail;

  2214     	return result;

  2215     	}

  2216     else

  2217     	{

  2218     	INFO_PRINTF1(_L("Supported drive modes include new EDriveTimeNudgeCapture - expected for CCamera::New2L()"));

  2219     	}

  2221 	__MM_HEAP_MARKEND;

  2222 	return result;

  2223 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--