1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #define __INCLUDE_CAPABILITY_NAMES__

    20 

    21 #include <e32test.h>

    22 #include <f32file.h>

    23 #include <test/testexecutelogger.h>

    24 #include "tuiscriptadaptors.h"

    25 #include "languagetable.h"

    26 

    27 #include <swi/launcher.h>

    28 #include <e32capability.h>

    29 #include <utf.h>

    30 

    31 using namespace Swi;

    32 using namespace Swi::Test;

    33 using namespace Xml;

    34 

    35 _LIT8(KParserDataType, "text/xml");

    36 _LIT8(KTrueValue,      "true");

    37 _LIT8(KFalseValue,     "false");

    38 _LIT8(KIndexType,      "item");

    39 _LIT8(KReturnType,     "return");

    40 _LIT8(KDialogName,     "dialog");

    41 _LIT8(KUpdateProgressReturn, "updateprogressreturn");

    42 _LIT8(KUpdateProgressFinalReturn, "updateprogressfinalreturn");

    43 

    44 

    45 enum TDialogs

    46 		{

    47 		KDisplayInstall1      = 1, 

    48 		KDisplayLanguage1,

    49 		KDisplayDrive1,

    50 		KDisplayUpgrade1,	

    51 		KDisplayOptions1,

    52 		KDisplaySecurityWarning1,

    53 		KDisplayOcspResult1,

    54 		KDisplayCannotOverwriteFile1,

    55 		KDisplayUninstall1,

    56 		KDisplayText1,

    57 		KDisplayError1,

    58 		KDisplayDependencyBreak1,

    59 		KDisplayApplicationsInUse1,

    60 		KDisplayQuestion1,

    61 		KDisplayMissingDependency1,

    62 		KInstallEvenDialogSetProgressBar,

    63 		KInstallEvenDialogUpdateProgressBar,

    64 		KInstallEvenDialogCompletedInstall,

    65 		KInstallEvenDialogOcspCheckEnd,

    66 		KInstallEvenDialogCompletedUnInstall,

    67 		KInstallEvenDevCert,

    68 		KCancelInstallRemoving,

    69 		KCancelInstallShuttingDown,

    70 		KCancelInstallCopyingFiles,

    71 		KCancelInstallOcspCheckStart

    72 		};

    73 /* Functions Literals */

    74 _LIT8(KDisplayInstall,               "DisplayInstall");

    75 _LIT8(KDisplayGrantCapabilities,     "DisplayGrantCapabilities");

    76 _LIT8(KDisplayLanguage,              "DisplayLanguage");

    77 _LIT8(KDisplayDrive,                 "DisplayDrive");

    78 _LIT8(KDisplayUpgrade,               "DisplayUpgrade");

    79 _LIT8(KDisplayOptions,               "DisplayOptions");

    80 _LIT8(KHandleInstallEvent,           "HandleInstallEvent");

    81 _LIT8(KHandleCancellableInstallEvent,"HandleCancellableInstallEvent");

    82 _LIT8(KDisplaySecurityWarning,       "DisplaySecurityWarning");

    83 _LIT8(KDisplayOcspResult,            "DisplayOcspResult");

    84 _LIT8(KDisplayCannotOverwriteFile,   "DisplayCannotOverwriteFile");

    85 _LIT8(KDisplayUninstall,             "DisplayUninstall");

    86 _LIT8(KDisplayText,                  "DisplayText");

    87 _LIT8(KDisplayError,                 "DisplayError");

    88 _LIT8(KDisplayDependencyBreak,       "DisplayDependencyBreak");

    89 _LIT8(KDisplayApplicationsInUse,     "DisplayApplicationsInUse");

    90 _LIT8(KDisplayQuestion,              "DisplayQuestion");

    91 _LIT8(KDisplayMissingDependency,     "DisplayMissingDependency");

    92 _LIT8(KDisplaySIDMismatch,           "DisplaySIDMismatch"); 

    93 

    94 #define	KGenericBufferSize		      100

    95 

    96 // Init defaults which will be overridden by script data (or not)

    97 TXmlFileData::TXmlFileData()

    98 	: InstallResult(ETrue)

    99 	, CapabilitiesResult(ETrue)

   100 	, LanguagesResult(0)

   101 	, DriveResult('c'-'a') // Default to installing to C:

   102 	, UpgradeResult(ETrue)

   103 	, OptionsResult(ETrue)

   104 	, WarningResult(ETrue)

   105 	, OcspResult(ETrue)

   106 	, UninstallResult(ETrue)

   107 	, TextResult(ETrue)

   108 	, DependencyResult(EFalse)

   109 	, ApplicationsInUseResult(ETrue)

   110 	, QuestionResult(EFalse)

   111 	, MissingDependencyResult(EFalse)

   112 	, DevCertsResult(ETrue)

   113 	, UpdateProgressBarResult(ETrue)

   114 	, ProgressBarFinalValueResult(ETrue)

   115 	{

   116 	}

   117 	

   118 CUIScriptAdaptor::CUIScriptAdaptor(const TFileName& aXmlFileName, CTestExecuteLogger& aLogger,

   119 								   RArray<TTableOfInstallSizes>* aExpectedValue)

   120 	:

   121 	iXmlFileName(aXmlFileName), 

   122 	iLogger(aLogger),

   123 	iExpectedValue(aExpectedValue),

   124 	iDelayDialogNumber(-1)

   125 	{

   126 	}

   127 

   128 CUIScriptAdaptor* CUIScriptAdaptor::NewLC(const TFileName& aXmlFileName, CTestExecuteLogger& aLogger,

   129 										  RArray<TTableOfInstallSizes>* aExpectedValue)

   130 	{

   131 	CUIScriptAdaptor* self = new(ELeave) CUIScriptAdaptor(aXmlFileName, aLogger, aExpectedValue);

   132 	CleanupStack::PushL(self);

   133 	self->ConstructL();

   134 	return self;

   135 	}

   136 

   137 CUIScriptAdaptor* CUIScriptAdaptor::NewL(const TFileName& aXmlFileName, CTestExecuteLogger& aLogger,

   138 										 RArray<TTableOfInstallSizes>* aExpectedValue)

   139 	{

   140 	CUIScriptAdaptor* self = NewLC(aXmlFileName, aLogger, aExpectedValue);

   141 	CleanupStack::Pop(self);

   142 	return self;

   143 	}

   144 	

   145 CUIScriptAdaptor::CUIScriptAdaptor(const TFileName& aXmlFileName, CTestExecuteLogger& aLogger,

   146 								   TPtrC aExpectedText,

   147 								   TPtrC aTextIsHash,

   148 								   TInt aExpectedDailog,

   149 								   TInt aKerrCode)

   150 	:

   151 	iXmlFileName(aXmlFileName), 

   152 	iLogger(aLogger),

   153 	iExpectedDisplayText(aExpectedText),

   154 	iExpectedHash(aTextIsHash),

   155 	iExpectedDialog(aExpectedDailog),

   156 	iKerrCode(aKerrCode),

   157 	iDelayDialogNumber(-1),

   158 	iDisplayedTextActual(NULL)

   159 	{

   160 	}

   161 	

   162 CUIScriptAdaptor* CUIScriptAdaptor::NewLC(const TFileName& aXmlFileName, CTestExecuteLogger& aLogger,

   163 										  TPtrC aExpectedText,

   164 										  TPtrC aTextIsHash,

   165 										  TInt aExpectedDailog,

   166 										  TInt aKerrCode

   167 										  )

   168 	{

   169 	CUIScriptAdaptor* self = new(ELeave) CUIScriptAdaptor(aXmlFileName, aLogger, aExpectedText, aTextIsHash, aExpectedDailog, aKerrCode);

   170 	CleanupStack::PushL(self);

   171 	self->ConstructL();

   172 	return self;

   173 	}

   174 

   175 CUIScriptAdaptor* CUIScriptAdaptor::NewL(const TFileName& aXmlFileName, CTestExecuteLogger& aLogger,

   176 	   								     TPtrC aExpectedText,

   177 	   								     TPtrC aTextIsHash,

   178 	   								     TInt aExpectedDailog,

   179 										 TInt aKerrCode

   180 	   								     )

   181 	{

   182 	CUIScriptAdaptor* self = NewLC(aXmlFileName, aLogger, aExpectedText,aTextIsHash, aExpectedDailog, aKerrCode);

   183 	CleanupStack::Pop(self);

   184 	return self;

   185 	}	

   186 void CUIScriptAdaptor::ConstructL()

   187 	{

   188 	User::LeaveIfError(iFs.Connect());

   189 	ScriptParseL();

   190 	}

   191 

   192 CUIScriptAdaptor::~CUIScriptAdaptor()

   193 	{

   194 	iResult.OptionSelection.Close();

   195 	iFs.Close();

   196     iObservedOcspOutcomes.ResetAndDestroy();

   197     delete iFileOwner;

   198    	delete iDisplayedTextActual;

   199 	}

   200 

   201 /**

   202  * The function is called to parse the XML file.

   203  */

   204 void CUIScriptAdaptor::ScriptParseL()

   205 	{

   206 	CRebuildingContentHandler* contentHandler = 

   207 		CRebuildingContentHandler::NewLC(iLogger);

   208 	

   209 	// Open parser session

   210 	CParser* parser = CParser::NewLC(KParserDataType, *contentHandler);

   211 	

   212 	// Starts parser session and active scheduler.

   213 	INFO_PRINTF1(_L("Parsing XML..."));

   214 	ParseL(*parser, iFs, iXmlFileName);

   215 			

   216 	iResult = contentHandler->GetOptions();

   217 	CleanupStack::PopAndDestroy(2, contentHandler); // parser, contentHandler

   218 	}

   219 

   220 /**

   221  * Extracts the nPos command line argument.

   222  */

   223 

   224 HBufC* GetArgumentL(TInt nPos)

   225 	{

   226 	HBufC *argv = HBufC::NewLC(User::CommandLineLength());

   227 	TPtr cmd(argv->Des());

   228 	User::CommandLine(cmd);

   229 

   230 	TLex arguments(cmd);

   231 

   232 	// finds nth parameter

   233 	while(nPos && !arguments.Eos())

   234 		{

   235 		TPtrC token = arguments.NextToken();

   236 		if(token.Length() > 0)

   237 			{

   238 			nPos--;

   239 			}

   240 		}

   241 

   242 	HBufC* result = NULL;

   243 

   244 	if(!arguments.Eos())

   245 		{

   246 		TPtrC testfile(arguments.NextToken());

   247 

   248 		if(testfile.Length() > 0)

   249 			{

   250 			result = testfile.AllocL();

   251 			}

   252 		};

   253 

   254 	// no parameter found, but must return something so..

   255 	if(!result)

   256 		{

   257 		result = HBufC::NewL(0);

   258 		}

   259 

   260 	CleanupStack::PopAndDestroy(argv);

   261 

   262 	return result;

   263 	}

   264 

   265 CRebuildingContentHandler* CRebuildingContentHandler::NewLC(

   266 	CTestExecuteLogger& aLogger)

   267 	{

   268 	CRebuildingContentHandler* self = new(ELeave) CRebuildingContentHandler(

   269 		aLogger);

   270 	CleanupStack::PushL(self);

   271 	return self;

   272 	}

   273 

   274 CRebuildingContentHandler* CRebuildingContentHandler::NewL(

   275 	CTestExecuteLogger& aLogger)

   276 	{

   277 	CRebuildingContentHandler* self = new(ELeave) CRebuildingContentHandler(

   278 		aLogger);

   279 	return self;

   280 	}

   281 

   282 CRebuildingContentHandler::CRebuildingContentHandler(

   283 	CTestExecuteLogger& aLogger)

   284 	: 

   285 	iError(KErrNone), 

   286 	iLogger(aLogger),

   287 	iLevel1(EScript)

   288 	{

   289 	}

   290 

   291 CRebuildingContentHandler::~CRebuildingContentHandler()

   292 	{

   293 	}

   294 

   295 void CRebuildingContentHandler::OnStartDocumentL(const RDocumentParameters& 

   296 											/*aDocParam*/, TInt aErrorCode)

   297 	{

   298 	User::LeaveIfError(aErrorCode);

   299 	}

   300 

   301 void CRebuildingContentHandler::OnEndDocumentL(TInt aErrorCode)

   302 	{

   303 	User::LeaveIfError(aErrorCode);

   304 	}

   305 	

   306 void CRebuildingContentHandler::OnStartElementL(const RTagInfo& aElement, 

   307 						const RAttributeArray& aAttributes, TInt aErrorCode)

   308 	{

   309 	User::LeaveIfError(aErrorCode);

   310 

   311 	TInt nAttributes = aAttributes.Count();

   312 	for(TInt i=0; i<nAttributes; i++)

   313 		{

   314 		const RAttribute& attribute = aAttributes[i];

   315 		const TDesC8& value8 = attribute.Value().DesC();

   316 		const TDesC8& tagname8 = aElement.LocalName().DesC();

   317 		switch(iLevel1)

   318 			{

   319 			case EScript:

   320 				if(value8.Compare(KDisplaySIDMismatch)==KErrNone)

   321 					{

   322 					 iLevel1 = EDisplaySIDMismatch;

   323 					  break;

   324 					}

   325 				else if (value8.Compare(KDisplayInstall) == KErrNone )

   326 					{

   327 					iLevel1 = EDisplayInstall;

   328 					break;

   329 					}

   330 				else if (value8.Compare(KDisplayGrantCapabilities) == KErrNone)

   331 					{

   332 					iLevel1 = EDisplayGrantCapabilities;

   333 					break;

   334 					}

   335 				else if (value8.Compare(KDisplayLanguage) == KErrNone )

   336 					{

   337 					iLevel1 = EDisplayLanguage;

   338 					break;

   339 					}

   340 				else if (value8.Compare(KDisplayDrive) == KErrNone )

   341 					{

   342 					iLevel1 = EDisplayDrive;

   343 					break;

   344 					}

   345 				else if (value8.Compare(KDisplayUpgrade) == KErrNone )

   346 					{

   347 					iLevel1 = EDisplayUpgrade;

   348 					break;

   349 					}

   350 				else if (value8.Compare(KDisplayOptions) == KErrNone )

   351 					{

   352 					iLevel1 = EDisplayOptions;

   353 					break;

   354 					}

   355 				else if (value8.Compare(KHandleInstallEvent) == KErrNone )

   356 					{

   357 					iLevel1 = EHandleInstallEvent;

   358 					break;

   359 					}

   360 				else if (value8.Compare(KHandleCancellableInstallEvent) == KErrNone )

   361 					{

   362 					iLevel1 = EHandleCancellableInstallEvent;

   363 					break;

   364 					}

   365 				else if (value8.Compare(KDisplaySecurityWarning) == KErrNone )

   366 					{

   367 					iLevel1 = EDisplaySecurityWarning;

   368 					break;

   369 					}

   370 				else if (value8.Compare(KDisplayOcspResult) == KErrNone )

   371 					{

   372 					iLevel1 = EDisplayOcspResult;

   373 					break;

   374 					}

   375 				else if (value8.Compare(KDisplayCannotOverwriteFile) == KErrNone )

   376 					{

   377 					iLevel1 = EDisplayCannotOverwriteFile;

   378 					break;

   379 					}

   380 				else if (value8.Compare(KDisplayUninstall) == KErrNone )

   381 					{

   382 					iLevel1 = EDisplayUninstall;

   383 					break;

   384 					}

   385 				else if (value8.Compare(KDisplayText) == KErrNone )

   386 					{

   387 					iLevel1 = EDisplayText;

   388 					break;

   389 					}

   390 				else if (value8.Compare(KDisplayError) == KErrNone )

   391 					{

   392 					iLevel1 = EDisplayError;

   393 					break;

   394 					}

   395 				else if (value8.Compare(KDisplayDependencyBreak) == KErrNone )

   396 					{

   397 					iLevel1 = EDisplayDependencyBreak;

   398 					break;

   399 					}

   400 				else if (value8.Compare(KDisplayApplicationsInUse) == KErrNone )

   401 					{

   402 					iLevel1 = EDisplayApplicationsInUse;

   403 					break;

   404 					}

   405 				else if (value8.Compare(KDisplayQuestion) == KErrNone )

   406 					{

   407 					iLevel1 = EDisplayQuestion;

   408 					break;

   409 					}

   410 				else if (value8.Compare(KDisplayMissingDependency) == KErrNone )

   411 					{

   412 					iLevel1 = EDisplayMissingDependency;

   413 					break;

   414 					}

   415 			case EDisplayInstall:

   416 			case EDisplayGrantCapabilities:

   417 			case EDisplayLanguage:

   418 			case EDisplayDrive:

   419 			case EDisplayUpgrade:

   420 			case EHandleCancellableInstallEvent:

   421 			case EDisplaySecurityWarning:

   422 			case EDisplayOcspResult:

   423 			case EDisplayCannotOverwriteFile:

   424 			case EDisplayUninstall:

   425 			case EDisplayText:

   426 			case EDisplayError:

   427 			case EDisplayDependencyBreak:

   428 			case EDisplayApplicationsInUse:

   429 			case EDisplayQuestion:

   430 			case EDisplayMissingDependency:

   431 			case EDisplaySIDMismatch:

   432 				if ( tagname8.Compare(KReturnType) == KErrNone )

   433 					{

   434 					iLevel2 = EReturn;

   435 					}

   436 				break;

   437 			case EDisplayOptions:

   438 				if ( tagname8.Compare(KIndexType) == KErrNone )

   439 					{

   440 					iLevel3 = EItemIndex;

   441 					}

   442 				else if ( tagname8.Compare(KReturnType) == KErrNone )

   443 						{

   444 						iLevel2 = EReturn;

   445 						}

   446 				break;

   447 			case EHandleInstallEvent:

   448 				if ( tagname8.Compare(KUpdateProgressReturn) == KErrNone )

   449 					{

   450 					iLevel2 = EUpdateProgress;

   451 					}

   452 				else if (tagname8.Compare(KUpdateProgressFinalReturn) == KErrNone )

   453 					{

   454 					iLevel2 = EUpdateProgressFinal;

   455 					}

   456 				else if ( tagname8.Compare(KReturnType) == KErrNone )

   457 					{

   458 					iLevel2 = EReturn;

   459 					}

   460 				break;

   461 			default:

   462 				break;

   463 			}

   464 		}

   465 	}

   466 

   467 void CRebuildingContentHandler::OnEndElementL(const RTagInfo& aElement, 

   468 												TInt aErrorCode)

   469 	{

   470 	User::LeaveIfError(aErrorCode);

   471 	const TDesC8& localPart8 = aElement.LocalName().DesC();

   472 	if ( localPart8.Compare(KDialogName) == KErrNone )

   473 		{

   474 		iLevel1 = EScript;

   475 		iLevel2 = KErrNone;

   476 		iLevel3 = KErrNone;

   477 		}

   478 	}

   479 

   480 void CRebuildingContentHandler::OnContentL(const TDesC8& aData8, 

   481 												TInt aErrorCode)

   482 	{

   483 	User::LeaveIfError(aErrorCode);

   484 

   485 	switch(iLevel1)

   486 		{

   487 		case EDisplayInstall:

   488 			if ( iLevel2 == EReturn )	

   489 				{

   490 				if ( aData8.Compare(KTrueValue) == KErrNone )

   491 					{

   492 					INFO_PRINTF1(_L("DisplayInstallL will return ETrue"));

   493 					iResult.InstallResult = ETrue;

   494 					}

   495 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   496 					{

   497 					INFO_PRINTF1(_L("DisplayInstallL will return EFalse"));

   498 					iResult.InstallResult = EFalse;

   499 					}

   500 				}

   501 			break;

   502 		case EDisplayGrantCapabilities:

   503 			if ( iLevel2 == EReturn )	

   504 				{

   505 				if ( aData8.Compare(KTrueValue) == KErrNone )

   506 					{

   507 					INFO_PRINTF1(_L("DisplayGrantCapabilitiesL will return ETrue"));

   508 					iResult.CapabilitiesResult = ETrue;

   509 					}

   510 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   511 					{

   512 					INFO_PRINTF1(_L("DisplayGrantCapabilitiesL will return EFalse"));

   513 					iResult.CapabilitiesResult = EFalse;

   514 					}

   515 				}

   516 			break;

   517 		case EDisplayLanguage:

   518 			if ( iLevel2 == EReturn )	

   519 				{

   520 				TName	tagdata;

   521 				TInt	lang=0;

   522 				tagdata.Copy(aData8);

   523 				tagdata.Trim();

   524 				TLex value(tagdata);

   525 				value.Val(lang);

   526 				if (!iLangLogged)

   527 					{

   528 					INFO_PRINTF2(_L("DisplayLanguageL will return %d"), lang);

   529 					iResult.LanguagesResult = lang;

   530 					iLangLogged = ETrue;

   531 					}

   532 				}

   533 			break;

   534 		case EDisplayDrive:

   535 			if ( iLevel2 == EReturn )	

   536 				{

   537 				TInt	drive=-1;

   538 				TName	tagdata;

   539 				tagdata.Copy(aData8);

   540 				tagdata.Trim();

   541 				

   542 				if (tagdata.Size() && TChar(tagdata[0]).IsAlphaDigit()) 

   543 					{

   544 					drive=tagdata[0]-'a';

   545 					}

   546 				if (!iDriveLogged)

   547 					{

   548 					INFO_PRINTF2(_L("DisplayDriveL will return drive '%c'"), drive+'A');

   549 					iResult.DriveResult = drive;

   550 					iDriveLogged = ETrue;

   551 					}

   552 				}

   553 			break;

   554 		case EDisplayUpgrade:

   555 			if ( iLevel2 == EReturn )

   556 				{

   557 				if ( aData8.Compare(KTrueValue) == KErrNone )

   558 					{

   559 					INFO_PRINTF1(_L("DisplayUpgradeL will return ETrue"));

   560 					iResult.UpgradeResult = ETrue;

   561 					}

   562 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   563 					{

   564 					INFO_PRINTF1(_L("DisplayUpgradeL will return EFalse"));

   565 					iResult.UpgradeResult = EFalse;

   566 					}

   567 				}

   568 			break;

   569 		case EDisplayOptions:

   570 			if ( iLevel3 == EItemIndex && iLevel2 != EReturn)

   571 				{			

   572 				if ( aData8.Compare(KTrueValue) == KErrNone )

   573 					{

   574 					/*

   575 					TBuf8<KGenericBufferSize> text;

   576 					text.Format(_L8 ("\015\012The Selection Index of the DisplayOptionsL	  : "));

   577 					iOutFile.Write(text);

   578 					iOutFile.Write(aData8);

   579 					*/

   580 					iResult.OptionSelection.Append(ETrue);

   581 					}

   582 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   583 					{

   584 					/*

   585 					TBuf8<KGenericBufferSize> text;

   586 					text.Format(_L8 ("\015\012The Selection Index of the DisplayOptionsL	  : "));

   587 					iOutFile.Write(text);

   588 					iOutFile.Write(aData8);

   589 					*/

   590 					iResult.OptionSelection.Append(EFalse);

   591 					}

   592 				}

   593 			else if ( iLevel2 == EReturn )	

   594 					{

   595 					if ( aData8.Compare(KTrueValue) == KErrNone )

   596 						{

   597 						/*

   598 						TBuf8<KGenericBufferSize> text;

   599 						text.Format(_L8 ("\015\012The Input value of the DisplayOptionsL	 	  : "));

   600 						iOutFile.Write(text);	

   601 						iOutFile.Write(aData8);

   602 						*/

   603 						iResult.OptionsResult = ETrue;

   604 						}

   605 					else if ( aData8.Compare(KFalseValue) == KErrNone )

   606 						{

   607 						/*

   608 						TBuf8<KGenericBufferSize> text;

   609 						text.Format(_L8 ("\015\012The Input value of the DisplayOptionsL	  : "));

   610 						iOutFile.Write(text);

   611 						iOutFile.Write(aData8);

   612 						*/

   613 						iResult.OptionsResult = EFalse;

   614 						}

   615 					}

   616 			break;

   617 			

   618 		case EHandleInstallEvent:

   619 			if (iLevel2 == EUpdateProgress)

   620 				{

   621 				if (aData8.Compare(KTrueValue) == KErrNone)

   622 					{

   623 					INFO_PRINTF1(_L("HandleInstallEvent-UpdateProgress will return ETrue"));

   624 					iResult.UpdateProgressBarResult = ETrue;

   625 					}

   626 				else if (aData8.Compare(KFalseValue) == KErrNone)

   627 					{

   628 					INFO_PRINTF1(_L("HandleInstallEvent-UpdateProgress will return EFalse"));

   629 					iResult.UpdateProgressBarResult = EFalse;

   630 					}

   631 				}

   632 			else if (iLevel2 == EUpdateProgressFinal)

   633 				{

   634 				if (aData8.Compare(KTrueValue) == KErrNone)

   635 					{

   636 					INFO_PRINTF1(_L("HandleInstallEvent-UpdateProgressFinal will return ETrue"));

   637 					iResult.ProgressBarFinalValueResult = ETrue;

   638 					}

   639 				else if (aData8.Compare(KFalseValue) == KErrNone)

   640 					{

   641 					INFO_PRINTF1(_L("HandleInstallEvent-UpdateProgressFinal will return EFalse"));

   642 					iResult.ProgressBarFinalValueResult = EFalse;

   643 					}

   644 				}

   645 			else if (iLevel2 == EReturn)

   646 				{

   647 				if (aData8.Compare(KTrueValue) == KErrNone)

   648 					{

   649 					INFO_PRINTF1(_L("HandleInstallEvent-DevCert will return ETrue"));

   650 					iResult.DevCertsResult = ETrue;

   651 					}

   652 				else if (aData8.Compare(KFalseValue) == KErrNone)

   653 					{

   654 					INFO_PRINTF1(_L("HandleInstallEvent-DevCert will return EFalse"));

   655 					iResult.DevCertsResult = EFalse;

   656 					}					

   657 				}

   658 			break;

   659 			

   660 		case EHandleCancellableInstallEvent:

   661 			// No return values for these events.

   662 			break;

   663 			

   664 		case EDisplaySecurityWarning:

   665 			if (iLevel2 == EReturn)

   666 				{

   667 				TBool found=EFalse;

   668 				if (aData8.Compare(KTrueValue) == KErrNone)

   669 					{

   670 					iResult.WarningResult = ETrue;

   671 					found=ETrue;

   672 					}

   673 				else if (aData8.Compare(KFalseValue) == KErrNone)

   674 					{

   675 					iResult.WarningResult = EFalse;

   676 					found=ETrue;

   677 					}

   678 					

   679 				if (found && !iSecWarnLogged)

   680 					{

   681 					_LIT(KETrue, "ETrue");

   682 					_LIT(KEFalse, "EFalse");

   683 					INFO_PRINTF2(

   684 						_L("DisplaySecurityWarningL will return '%S'"), 

   685 						iResult.WarningResult ? &KETrue : &KEFalse);

   686 					iSecWarnLogged=ETrue;

   687 					}

   688 				}

   689 			break;

   690 			

   691 		case EDisplayOcspResult:

   692 			if ( iLevel2 == EReturn )

   693 				{

   694 				if ( aData8.Compare(KTrueValue) == KErrNone )

   695 					iResult.OcspResult = ETrue;

   696 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   697 					iResult.OcspResult = EFalse;

   698 				_LIT(KETrue, "ETrue");

   699 				_LIT(KEFalse, "EFalse");

   700 				INFO_PRINTF2(

   701 					_L("DisplayOcspResultL will return '%S'"), 

   702 					iResult.OcspResult ? &KETrue : &KEFalse);

   703 				}

   704 			break;

   705 		case EDisplayCannotOverwriteFile:

   706 			break;

   707 			

   708 		case EDisplayUninstall:

   709 			if ( iLevel2 == EReturn )

   710 				{

   711 				if ( aData8.Compare(KTrueValue) == KErrNone )

   712 					{

   713 					INFO_PRINTF1(_L("DisplayUninstallL will return ETrue"));

   714 					iResult.UninstallResult = ETrue;

   715 					}

   716 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   717 					{

   718 					INFO_PRINTF1(_L("DisplayUninstallL will return EFalse"));

   719 					iResult.UninstallResult = EFalse;

   720 					}

   721 				}

   722 			break;

   723 			

   724 		case EDisplayText:

   725 			if ( iLevel2 == EReturn )

   726 				{

   727 				if ( aData8.Compare(KTrueValue) == KErrNone )

   728 					{

   729 					/*

   730 					TBuf8<KGenericBufferSize> text;

   731 					text.Format(_L8 ("\015\012The Input value of the DisplayTextL		  : "));

   732 					iOutFile.Write(text);

   733 					iOutFile.Write(aData8);

   734 					*/

   735 					iResult.TextResult = ETrue;

   736 					}

   737 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   738 					{

   739 					/*

   740 					TBuf8<KGenericBufferSize> text;

   741 					text.Format(_L8 ("\015\012The Input value of the DisplayTextL		  : "));

   742 					iOutFile.Write(text);

   743 					iOutFile.Write(aData8);

   744 					*/

   745 					iResult.TextResult = EFalse;

   746 					}

   747 				}

   748 			break;

   749 		case EDisplayError:

   750 			break;

   751 		case EDisplayDependencyBreak:

   752 			if ( iLevel2 == EReturn )

   753 				{

   754 				if ( aData8.Compare(KTrueValue) == KErrNone )

   755 					{

   756 					/*

   757 					TBuf8<KGenericBufferSize> text;

   758 					text.Format(_L8 ("\015\012The Input value of the DisplayDependencyBreakL    : "));

   759 					iOutFile.Write(text);

   760 					iOutFile.Write(aData8);

   761 					*/

   762 					iResult.DependencyResult = ETrue;

   763 					}

   764 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   765 					{

   766 					/*

   767 					TBuf8<KGenericBufferSize> text;

   768 					text.Format(_L8 ("\015\012The Input value of the DisplayDependencyBreakL    : "));

   769 					iOutFile.Write(text);

   770 					iOutFile.Write(aData8);

   771 					*/

   772 					iResult.DependencyResult = EFalse;

   773 					}

   774 				}

   775 			break;

   776 		case EDisplayApplicationsInUse:

   777 			if ( iLevel2 == EReturn )

   778 				{

   779 				if ( aData8.Compare(KTrueValue) == KErrNone )

   780 					{

   781 					/*

   782 					TBuf8<KGenericBufferSize> text;

   783 					text.Format(_L8 ("\015\012The Input value of the DisplayApplicationsInUseL  : "));

   784 					iOutFile.Write(text);

   785 					iOutFile.Write(aData8);

   786 					*/

   787 					iResult.ApplicationsInUseResult = ETrue;

   788 					}

   789 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   790 					{

   791 					/*

   792 					TBuf8<KGenericBufferSize> text;

   793 					text.Format(_L8 ("\015\012The Input value of the DisplayApplicationsInUseL  : "));

   794 					iOutFile.Write(text);

   795 					iOutFile.Write(aData8);

   796 					*/

   797 					iResult.ApplicationsInUseResult = EFalse;

   798 					}

   799 				}

   800 			break;

   801 		case EDisplayQuestion:

   802 			if ( iLevel2 == EReturn )

   803 				{

   804 				if ( aData8.Compare(KTrueValue) == KErrNone )

   805 					{

   806 					/*

   807 					TBuf8<KGenericBufferSize> text;

   808 					text.Format(_L8 ("\015\012The Input value of the DisplayQuestionL		  : "));

   809 					iOutFile.Write(text);

   810 					iOutFile.Write(aData8);

   811 					*/

   812 					iResult.QuestionResult = ETrue;

   813 					}

   814 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   815 					{

   816 					/*

   817 					TBuf8<KGenericBufferSize> text;

   818 					text.Format(_L8 ("\015\012The Input value of the DisplayQuestionL		  : "));

   819 					iOutFile.Write(text);

   820 					iOutFile.Write(aData8);

   821 					*/

   822 					iResult.QuestionResult = EFalse;

   823 					}

   824 				}

   825 			break;

   826 		case EDisplayMissingDependency:

   827 			if (iLevel2 == EReturn)

   828 				{

   829 				if (aData8.Compare(KTrueValue)==KErrNone)

   830 					{

   831 					INFO_PRINTF1(_L("DisplayMissingDependencyL will return ETrue"));

   832 					iResult.MissingDependencyResult = ETrue;

   833 					}

   834 				else if ( aData8.Compare(KFalseValue) == KErrNone )

   835 					{

   836 					INFO_PRINTF1(_L("DisplayMissingDependencyL will return EFalse"));

   837 					iResult.MissingDependencyResult = EFalse;

   838 					}

   839 				}

   840 			break;

   841 		default:

   842 			break;

   843 		}

   844 	}

   845 

   846 void CRebuildingContentHandler::OnStartPrefixMappingL(const RString& /*aPrefix*/, 

   847 									  const RString& /*aUri*/, TInt aErrorCode)

   848 	{

   849 	User::LeaveIfError(aErrorCode);

   850 	}

   851 

   852 void CRebuildingContentHandler::OnEndPrefixMappingL(const RString& /*aPrefix*/, 

   853 													TInt aErrorCode)

   854 	{

   855 	User::LeaveIfError(aErrorCode);

   856 	}

   857 

   858 void CRebuildingContentHandler::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, 

   859 													  TInt /*aErrorCode*/)

   860 	{

   861 	}

   862 

   863 void CRebuildingContentHandler::OnSkippedEntityL(const RString& /*aName*/, 

   864 												 TInt /*aErrorCode*/)

   865 	{

   866 	}

   867 

   868 void CRebuildingContentHandler::OnProcessingInstructionL(const TDesC8& /*aTarget8*/, 

   869 									 const TDesC8& /*aData8*/, TInt aErrorCode)

   870 	{

   871 	User::LeaveIfError(aErrorCode);

   872 	}

   873 

   874 void CRebuildingContentHandler::OnExtensionL(const RString& /*aData*/, 

   875 										TInt /*aToken*/, TInt /*aErrorCode*/)

   876 	{

   877 	/*

   878 	_LIT(KUnsupportedFeature,"Illegal call to TRebuildingContentHandler:: \

   879 												OnExtensionL - aborting\n");

   880 	test.Panic(KErrNotSupported, KUnsupportedFeature);

   881 	*/

   882 	}

   883 

   884 void CRebuildingContentHandler::OnOutOfData()

   885 	{

   886 	//_LIT(KUnexpectedOutOfData,"Unexpected call to OnOutOfData - aborting\n");

   887 	}

   888 

   889 void CRebuildingContentHandler::OnError(TInt aError)

   890 	{

   891 	iError = aError;

   892 //	test.Printf(_L("TRebuildingContentHandler::OnError - ERROR: code=%d - \

   893 //									  Aborting parsing process\n"), aError);

   894 	}

   895 

   896 TAny* CRebuildingContentHandler::GetExtendedInterface(const TInt32)

   897 	{

   898 	return NULL;

   899 	}

   900 	

   901 

   902 TXmlFileData& CRebuildingContentHandler::GetOptions()

   903 	{

   904 	return iResult;

   905 	}

   906 

   907 // CUISCriptAdaptor functions

   908 void CUIScriptAdaptor::DialogReached()

   909 	{

   910 

   911 	if ((iDialogDelay.Int() != 0) &&

   912 		(iDelayDialogNumber < 0 || iDelayDialogNumber == iCurrentDialogNumber))

   913 			{

   914 			// We need to make sure that (un)installation is not too quick,

   915 			// otherwise the async cancel tests will fail.

   916 			User::After(iDialogDelay);

   917 			}

   918 

   919 	if ((iCurrentDialogNumber++ == iCancelDialogNumber) &&

   920 		(iDialogCancelType == ECancelFromDialog ||

   921 		 iDialogCancelType == ECancelAfterDialog))

   922 		{

   923 		iInstallationCancelled=ETrue;

   924 		// Cancel the installation

   925 

   926 		if (iDialogCancelType == ECancelFromDialog)

   927 			{

   928 			if(iCancelHandler)

   929 				{

   930 				INFO_PRINTF1(_L("Canceling via CancellableInstallEvent callback"));

   931 				iCancelHandler->HandleCancel();

   932 				}

   933 			else

   934 				{

   935 				INFO_PRINTF1(_L("Cancelling via static Cancel API"));

   936 				Launcher::Cancel();

   937 				}	

   938 			}

   939 		else

   940 			{

   941 			// Cancelling after a dialog is done for the async install

   942 			// and uninstall steps.  Stopping the active scheduler will let

   943 			// CSwisAsyncStep::RunOperation start a cancel delay timer, and

   944 			// the cancel will actually be invoked when the timer expires.

   945 			// The install or uninstall will carry on until this happens.

   946 			INFO_PRINTF1(_L("Calling CActiveScheduler::Stop()"));

   947 			CActiveScheduler::Stop();

   948 			}

   949 		}

   950 

   951 	if (iCurrentDialogNumber > iCancelDialogNumber && 

   952 		(iDialogCancelType == ECancelFromDialog ||

   953 		 iDialogCancelType == ECancelAfterDialog))

   954 		{

   955 		ERR_PRINTF3(_L("Reached an unexpected dialog. Dialogs expected: %d, dialog reached: %d"), iCancelDialogNumber, iCurrentDialogNumber);

   956 		}

   957 	}

   958 

   959 

   960 void CUIScriptAdaptor::DisplayAppInfo(const TDesC& aPreText, const CAppInfo& aAppInfo)

   961 	{

   962 	INFO_PRINTF7(_L("\t%S {\"%S\", \"%S\", V%u.%u.%u}"),

   963 		&aPreText,

   964 		&aAppInfo.AppName(), &aAppInfo.AppVendor(),

   965 		aAppInfo.AppVersion().iMajor,

   966 		aAppInfo.AppVersion().iMinor,

   967 		aAppInfo.AppVersion().iBuild);

   968 	}

   969 

   970 void CUIScriptAdaptor::DisplayBoolReturn(TBool aReturn)

   971 	{

   972 	_LIT(KTrue, "True");

   973 	_LIT(KFalse, "False");

   974 	INFO_PRINTF2(_L("\tReturning %S"), aReturn ? &KTrue : &KFalse);

   975 	}

   976 

   977 void CUIScriptAdaptor::DisplayIntReturn(TInt aReturn)

   978 	{

   979 	INFO_PRINTF2(_L("\tReturning %d"), aReturn);

   980 	}

   981 	

   982 void CUIScriptAdaptor::CheckFinalProgressBarL()

   983 	{

   984 	if (iProgressBarCurrent != iProgressBarFinal)

   985 		{

   986 		INFO_PRINTF3(_L("\tProgress for installation not finished %d out of %d"), iProgressBarCurrent, iProgressBarFinal);

   987 		User::Leave(KErrAbort);

   988 		}

   989 	}

   990 

   991 void CUIScriptAdaptor::CheckExpectedAndCalculatedInstallSizesL(const TDesC& aAppInfoName, TInt64 aSize)

   992 	{		

   993 	TInt i=0;

   994 	TBool foundExpectedInstallSize = EFalse;

   995 	

   996 	RArray<TTableOfInstallSizes> arrayOfExpectedValues = *iExpectedValue;

   997 

   998 	while ((!foundExpectedInstallSize) && (i<arrayOfExpectedValues.Count()))

   999 		{

  1000 		if (arrayOfExpectedValues[i].iPkgFileName == aAppInfoName)

  1001 			{

  1002 			if (arrayOfExpectedValues[i].iInstallSize != aSize)

  1003 				{

  1004 				INFO_PRINTF3(_L("\tThe calculated install size (%D bytes) does not match the expected install size (%D bytes)."),

  1005 								I64LOW(aSize), arrayOfExpectedValues[i].iInstallSize);

  1006 				User::Leave(KErrAbort);

  1007 				}

  1008 			else

  1009 				{

  1010 				INFO_PRINTF2(_L("\tSize (calculated value matches expected value): %D bytes."), I64LOW(aSize));

  1011 				foundExpectedInstallSize = ETrue;

  1012 				}

  1013 			}

  1014 		else

  1015 			{

  1016 			i = i + 1;

  1017 			}

  1018 		}

  1019 	if (!foundExpectedInstallSize)

  1020 		{

  1021 		INFO_PRINTF2(_L("\tThe calculated install size (%D bytes) does not match any of the expected install sizes."),

  1022 						I64LOW(aSize));

  1023 		User::Leave(KErrAbort);

  1024 		}

  1025 	}

  1026 	

  1027 	

  1028 //

  1029 // Implementation for the virtual functions for the MUiHandler class. 

  1030 //

  1031 

  1032 /**

  1033  * Displays Install dialog and logs all incoming information.

  1034  *

  1035  * @param aAppInfo      Application information.

  1036  * @param aLogo         Optional bitmap logo.

  1037  * @param aCertificates Array of end-entity certificates (can be empty).

  1038  *

  1039  * @return A value from script: \b ETrue to continue, \b EFalse to abort 

  1040  *         installation.

  1041  */

  1042 TBool CUIScriptAdaptor::DisplayInstallL(const CAppInfo& aAppInfo,

  1043 	const CApaMaskedBitmap* aLogo,

  1044 	const RPointerArray<CCertificateInfo>& aCertificates)

  1045 	{

  1046 	INFO_PRINTF1(_L("DisplayInstallL():"));

  1047 	DisplayAppInfo(_L("AppInfo:"), aAppInfo);

  1048 	TInt bootMode = 0;

  1049 	User::LeaveIfError(RProperty::Get(KUidSystemCategory, KSystemStartupModeKey, bootMode));

  1050 	(void) aLogo;

  1051 	if (aCertificates.Count())

  1052 		{

  1053 		INFO_PRINTF2(_L("\tCertificate(s): %u"),aCertificates.Count());

  1054 		for (TInt i=0; i<aCertificates.Count(); i++)

  1055 			{

  1056 			INFO_PRINTF4(_L("\t[%02u] Subj: \"%S\", Issuer: \"%S\""),i,

  1057 				&aCertificates[i]->SubjectName(),

  1058 				&aCertificates[i]->IssuerName());

  1059 

  1060 			TTime validFrom(aCertificates[i]->ValidFrom());

  1061 			TTime validTo(aCertificates[i]->ValidTo());

  1062 			TBuf<KMaxLongDateFormatSpec> validFromBuf, validToBuf;

  1063 			validFrom.FormatL(validFromBuf, TLongDateFormatSpec());

  1064 			validTo.FormatL(validToBuf, TLongDateFormatSpec());

  1065 			INFO_PRINTF3(_L("\t     ValidFrom: \"%S\", ValidTo: \"%S\""),

  1066 				&validFromBuf, &validToBuf);

  1067 			}

  1068 		}

  1069 	

  1070 	LeaveError(KDisplayInstall1);	

  1071 	DialogReached();

  1072 	DisplayBoolReturn(iResult.InstallResult);

  1073 	return iResult.InstallResult;

  1074 	}

  1075 

  1076 TBool CUIScriptAdaptor::DisplayGrantCapabilitiesL(const CAppInfo& aAppInfo, 

  1077 	const TCapabilitySet& aCapabilitySet)

  1078    {

  1079    iGrantUserCapsDialogCalled=ETrue;

  1080    

  1081    INFO_PRINTF1(_L("DisplayGrantCapabilitiesL():"));

  1082   	DisplayAppInfo(_L("AppInfo:"), aAppInfo);

  1083 

  1084 	// Build requested capabilities string.

  1085 	const TInt KMaxBufSize=512; // should be enough for all capability names

  1086 	const TInt KMaxCapName=64; // should be enough for one capability name

  1087 	_LIT(KSpace," ");

  1088 	HBufC* buf=HBufC::NewLC(KMaxBufSize);

  1089 	TPtr p=buf->Des();

  1090 	TInt capsAppended=0;

  1091 	TBuf8<KMaxCapName> capName8;

  1092 	TBuf<KMaxCapName> capName;

  1093 

  1094 	for (TInt i=0; i<ECapability_HardLimit; i++)

  1095 		{

  1096 		if (aCapabilitySet.HasCapability(static_cast<TCapability>(i)))

  1097 			{

  1098 			if (capsAppended)

  1099 				p.Append(KSpace);

  1100 			capName8=reinterpret_cast<const TUint8*>(CapabilityNames[i]);

  1101 			capName.Copy(capName8);

  1102 			p.Append(capName);

  1103 			capsAppended++;

  1104 			}

  1105 		}

  1106 

  1107 	INFO_PRINTF2(_L("\tRequesting capabilities: %S"),&p);

  1108 	CleanupStack::PopAndDestroy(buf);

  1109 

  1110 	DialogReached();

  1111 	DisplayBoolReturn(iResult.CapabilitiesResult);

  1112 	return iResult.CapabilitiesResult;

  1113 	}

  1114 

  1115 

  1116 TInt CUIScriptAdaptor::DisplayLanguageL(const CAppInfo& aAppInfo, 

  1117 						 const RArray<TLanguage>& aLanguages)

  1118 	{

  1119 	INFO_PRINTF1(_L("DisplayLanguageL():"));

  1120 	DisplayAppInfo(_L("AppInfo:"), aAppInfo);

  1121 

  1122 	HBufC* languages=HBufC::NewLC(1024);

  1123 	TPtr pLanguages(languages->Des());

  1124 

  1125 	for (TInt i=0; i < aLanguages.Count();)

  1126 		{

  1127 		pLanguages.AppendFormat(_L("%S"), &KLanguageTable[aLanguages[i]]);

  1128 		if (++i  >= aLanguages.Count())

  1129 			break;

  1130 		pLanguages.Append(_L(", "));

  1131 		}

  1132 	INFO_PRINTF2(_L("\tLanguages: %S"), &pLanguages);

  1133 	CleanupStack::PopAndDestroy(languages);

  1134 

  1135 	LeaveError(KDisplayLanguage1);