1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // T_TestStepBackup.cpp

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @released

    21 */

    22 

    23 #include "t_teststepbackupasync.h"

    24 

    25 

    26 namespace bur_ts

    27 	{

    28 			

    29 	CBURTestStepBackupAsync* CBURTestStepBackupAsync::NewL(CBURTestServer& aTestServer)

    30 		/**

    31 		Symbian OS Constructor

    32 		

    33 		@internalComponent

    34 		@released

    35 		

    36 		@param aParent - The parent CBURTestServer of this child test step.

    37 		@return Pointer to a newly created CBURTestStepBackup object.

    38 		*/

    39 		{

    40 		CBURTestStepBackupAsync* self = new (ELeave) CBURTestStepBackupAsync(aTestServer);

    41 		CleanupStack::PushL(self);

    42 		self->ConstructL();

    43 		CleanupStack::Pop();

    44 		return self;

    45 		}

    46 

    47 	CBURTestStepBackupAsync::CBURTestStepBackupAsync(CBURTestServer& aTestServer)

    48 		/**

    49 		C++ Constructor

    50 		

    51 		@internalComponent

    52 		@released

    53 		

    54 		@param aParent - The parent CBURTestServer of this child test step.

    55 		*/

    56 		: CBURTestStepBase(aTestServer), iDataTransferHandler(NULL)

    57 		{}

    58 	

    59 	void CBURTestStepBackupAsync::ConstructL()

    60 		/**

    61 		Symbian OS 2nd-phase Constructor

    62 		

    63 		@internalComponent

    64 		@released

    65 		*/

    66 		{

    67 		TInt error;

    68 		

    69 		// Initialise the drive list to empty

    70 		iDriveList.FillZ();

    71 		

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

    73 		

    74 		// Install an active scheduler for this test step

    75 		iActiveScheduler = new(ELeave) CActiveScheduler;

    76 		CActiveScheduler::Install(iActiveScheduler);

    77 		

    78 		TRAP(error, iBackupClient = CSBEClient::NewL());

    79 		if (error != KErrNone)

    80 			{

    81 			_LIT(KClientConnection, "SBEClientConnection");

    82 			User::Panic(KClientConnection,error);

    83 			}

    84 			

    85 		_LIT(KBURTBackup, "BURTestServerBackup");

    86 		User::RenameThread(KBURTBackup);

    87 		//User::SetCritical(User::ESystemCritical);

    88 		

    89 		SetTestStepName(KBURTestBackupAsync);

    90 		}

    91 	

    92 	CBURTestStepBackupAsync::~CBURTestStepBackupAsync()

    93 		/**

    94 		C++ Destructor

    95 		

    96 		@internalComponent

    97 		@released

    98 		*/

    99 		{

   100 		delete iDataTransferHandler;

   101 		}

   102 

   103 	TVerdict CBURTestStepBackupAsync::doTestStepPreambleL()

   104 		/**

   105 		Override of base class virtual function

   106 		

   107 		@internalComponent

   108 		@released

   109 		

   110 		@return TVerdict code

   111 		*/

   112 		{

   113 		SetTestStepResult(EPass);

   114 		return TestStepResult();

   115 		}

   116 

   117 	TVerdict CBURTestStepBackupAsync::doTestStepL()

   118 		/**

   119 		Override of base class pure virtual

   120 		

   121 		@internalComponent

   122 		@released

   123 		

   124 		@return TVerdict code

   125 		*/

   126 		{

   127 		_LIT(KLog1, "Processing user options...");

   128 		Log(LOG_LEVEL2, KLog1);

   129 		ProcessUserOptionsL();

   130 		

   131 		// Get a list of data owners:

   132 		PopulateListOfDataOwnersAsyncL();

   133 		

   134 		

   135 		TBURPartType type = EBURBackupFull;

   136 		

   137 		if (iIsPartial)

   138 			{

   139 			_LIT(KLog2, "Preparing for PARTIAL backup...");

   140 			Log(LOG_LEVEL2, KLog2);

   141 			type = EBURBackupPartial;

   142 			PrepareForPartialBURL();

   143 			SetSIDListForPartialL();

   144 			}

   145 		else

   146 			{

   147 			_LIT(KLog3, "Preparing for FULL backup...");

   148 			Log(LOG_LEVEL2, KLog3);

   149 			}

   150 		

   151 		CheckValidRegistrationL();

   152 		

   153 		_LIT(KLog4, "Saving Data Owners...");

   154 		Log(LOG_LEVEL2, KLog4);

   155 		SaveDataOwners();

   156 		

   157 		Log(LOG_LEVEL2, _L("Setting backup mode..."));

   158 		TRAPD(err,SetBURModeAsyncL(type, iBackupIncType));

   159 		if (err != KErrNone)

   160 			{

   161 			_LIT(KBURError, "Error setting Backup mode ");

   162 			Log(LOG_LEVEL3, KBURError);

   163 			}

   164 		

   165 		iDataTransferHandler = CAsyncBackupTransferHandler::NewL(this);

   166 		Log(LOG_LEVEL2, _L("Starting backup..."));

   167 		

   168 		//BackupRegistrationDataL();

   169 		

   170 		BackupPublicDataL();

   171 		

   172 		BackupJavaMidletsL();

   173 		BackupJavaMidletsDataL();

   174 		

   175 		// Backup data according to user preferences

   176 		if (iBackupIncType == EBackupIncrement)

   177 			{

   178 			IncrementalBackupL();

   179 			}

   180 		else

   181 			{

   182 			BaseBackupL();

   183 			}

   184 			

   185 		Log(LOG_LEVEL2, _L("Setting backup mode to Normal ..."));

   186 		TRAPD(err2,SetBURModeL(EBURNormal, ENoBackup));

   187 		if (err2 != KErrNone)

   188 			{

   189 			_LIT(KBURError, "Error setting Backup mode ");

   190 			Log(LOG_LEVEL3, KBURError);

   191 			}

   192 		

   193 		

   194 		return TestStepResult();

   195 		}

   196 	

   197 	void CBURTestStepBackupAsync::BaseBackupL()

   198 		/**

   199 		@internalComponent

   200 		@released

   201 		*/

   202 		{

   203 		// system data

   204 		BackupSystemBaseDataL();

   205 		BackupSystemSnapshotDataL();

   206 		

   207 		//active

   208 		BackupActiveBaseDataL();

   209 		BackupActiveSnapshotDataL();

   210 		

   211 		//passive

   212 		BackupPassiveBaseDataL();

   213 		BackupPassiveSnapshotDataL();

   214 		}

   215 	

   216 	void CBURTestStepBackupAsync::IncrementalBackupL()

   217 		/**

   218 		@internalComponent

   219 		@released

   220 		*/

   221 		{

   222 		_LIT(KInc, "Backup mode: INCREMENTAL");

   223 		Log(LOG_LEVEL2, KInc);

   224 		//active

   225 		SupplySystemSnapshotDataL();

   226 		SupplyActiveSnapshotDataL();

   227 		SupplyPassiveSnapshotDataL();

   228 		

   229 		CBURActiveObject* active = CBURActiveObject::NewL();

   230 		CleanupStack::PushL(active);

   231 		TRAPD(err,iBackupClient->AllSnapshotsSuppliedL(active->iStatus));

   232 		if (err == KErrNone)

   233 			{

   234 			active->StartL();

   235 			}

   236 		

   237 		if (err != KErrNone || active->Error() != KErrNone)

   238 			{

   239 			_LIT(KSnapErr, "Error Supplying Snapshot Data ");

   240 			LogWithNum(LOG_LEVEL3, KSnapErr, err);

   241 			}

   242 		else

   243 			{

   244 			_LIT(KSnap, "All Snapshots Supplied");

   245 			Log(LOG_LEVEL3, KSnap);

   246 			}

   247 		

   248 		CleanupStack::PopAndDestroy(active);

   249 		

   250 		// system data

   251 		BackupSystemBaseDataL();

   252 		BackupSystemSnapshotDataL();

   253 		

   254 		// active

   255 		BackupActiveIncDataL();

   256 		BackupActiveSnapshotDataL();

   257 		

   258 		//passive

   259 		BackupPassiveIncDataL();

   260 		BackupPassiveSnapshotDataL();

   261 		}

   262 		

   263 	void CBURTestStepBackupAsync::BackupSystemBaseDataL()

   264 		/**

   265 		@internalComponent

   266 		@released

   267 		*/

   268 		{

   269 		_LIT(KLog, "Backup System Data ...");

   270 		Log(LOG_LEVEL2, KLog);

   271 		GeneratePIDTransferTypesL(iTransferTypes, ESystemData);

   272 		DoBackupL();

   273 		}

   274 		

   275 	void CBURTestStepBackupAsync::SupplySystemSnapshotDataL()

   276 		/**

   277 		@internalComponent

   278 		@released

   279 		*/

   280 		{

   281 		GeneratePIDTransferTypesL(iTransferTypes, ESystemSnapshotData);

   282 		// go through each of them and check if we have snapshot to supply

   283 		if (iTransferTypes.Count())

   284 			{

   285 			_LIT(KLog, "Supply System Snapshot Data ...");

   286 			Log(LOG_LEVEL2, KLog);

   287 			SupplyDataL(iTransferTypes);

   288 			}

   289 		}

   290 		

   291 	void CBURTestStepBackupAsync::BackupSystemSnapshotDataL()

   292 		/**

   293 		@internalComponent

   294 		@released

   295 		*/

   296 		{

   297 		_LIT(KLog, "Backup System Snapshot Data ...");

   298 		Log(LOG_LEVEL2, KLog);

   299 		GeneratePIDTransferTypesL(iTransferTypes, ESystemSnapshotData);

   300 		DoBackupL();

   301 		}

   302 	

   303 	

   304 	void CBURTestStepBackupAsync::BackupRegistrationDataL()

   305 		/**

   306 		@internalComponent

   307 		@released

   308 		*/

   309 		{

   310 		_LIT(KReg, "Backup registration data...");

   311 		Log(LOG_LEVEL2, KReg);

   312 		GenerateSIDTransferTypesL(iTransferTypes, ERegistrationData);

   313 		DoBackupL();

   314 		}

   315 	

   316 	void CBURTestStepBackupAsync::BackupPassiveSnapshotDataL()

   317 		/**

   318 		@internalComponent

   319 		@released

   320 		*/

   321 		{

   322 		_LIT(KPassSnap, "Backup passive snapshot data...");

   323 		Log(LOG_LEVEL2, KPassSnap);

   324 		GenerateSIDTransferTypesL(iTransferTypes, EPassiveSnapshotData);

   325 		DoBackupL();

   326 		}

   327 	

   328 	void CBURTestStepBackupAsync::SupplyPassiveSnapshotDataL()

   329 		/**

   330 		@internalComponent

   331 		@released

   332 		*/

   333 		{

   334 		_LIT(KSupp, "Supplying passive snapshot data...");

   335 		Log(LOG_LEVEL2, KSupp);

   336 		DoSupplyL(EPassiveSnapshotData);

   337 		}

   338 

   339 	void CBURTestStepBackupAsync::BackupPassiveBaseDataL()

   340 		/**

   341 		@internalComponent

   342 		@released

   343 		*/

   344 		{

   345 		_LIT(KPassBase, "Backup passive base data...");

   346 		Log(LOG_LEVEL2, KPassBase);

   347 		GenerateSIDTransferTypesL(iTransferTypes, EPassiveBaseData);

   348 		DoBackupL();

   349 		}

   350 	

   351 	void CBURTestStepBackupAsync::BackupPassiveIncDataL()

   352 		/**

   353 		@internalComponent

   354 		@released

   355 		*/

   356 		{

   357 		_LIT(KPassInc, "Backup passive incremental data...");

   358 		Log(LOG_LEVEL2, KPassInc);

   359 		GenerateSIDTransferTypesL(iTransferTypes, EPassiveIncrementalData);

   360 		DoBackupL();

   361 		}

   362 	

   363 	void CBURTestStepBackupAsync::BackupActiveSnapshotDataL()

   364 		/**

   365 		@internalComponent

   366 		@released

   367 		*/

   368 		{

   369 		_LIT(KActSnap, "Backup active snapshot data...");

   370 		Log(LOG_LEVEL2, KActSnap);

   371 		DoActiveBackupL(EActiveSnapshotData);

   372 		}

   373 	

   374 	void CBURTestStepBackupAsync::SupplyActiveSnapshotDataL()

   375 		/**

   376 		@internalComponent

   377 		@released

   378 		*/

   379 		{

   380 		_LIT(KSuppActSnap,"Supplying active snapshot data...");

   381 		Log(LOG_LEVEL2, KSuppActSnap);

   382 		DoSupplyL(EActiveSnapshotData);

   383 		}

   384 	

   385 	void CBURTestStepBackupAsync::BackupActiveBaseDataL()

   386 		/**

   387 		@internalComponent

   388 		@released

   389 		*/

   390 		{

   391 		_LIT(KActBase, "Backup active base data...");

   392 		Log(LOG_LEVEL2, KActBase);

   393 		DoActiveBackupL(EActiveBaseData);

   394 		}

   395 

   396 	void CBURTestStepBackupAsync::BackupActiveIncDataL()

   397 		/**

   398 		@internalComponent

   399 		@released

   400 		*/

   401 		{

   402 		_LIT(KActInc, "Backup active incremental data...");

   403 		Log(LOG_LEVEL2, KActInc);

   404 		DoActiveBackupL(EActiveIncrementalData);

   405 		}

   406 		

   407 	void CBURTestStepBackupAsync::BackupPublicDataL()

   408 		/**

   409 		@internalComponent

   410 		@released

   411 		*/

   412 		{

   413 		_LIT(KPublic, "Backup Public Data...");

   414 		Log(LOG_LEVEL2, KPublic);

   415 		RPointerArray<CSBGenericDataType> array;

   416 		TRAP_IGNORE(GeneratePublicTransferTypesL(array));

   417 		TRAP_IGNORE(DoPublicBackupL(array));

   418 		array.ResetAndDestroy();

   419 		array.Close();

   420 		}

   421 		

   422 	void CBURTestStepBackupAsync::DoPublicBackupL(RPointerArray<CSBGenericDataType>& aTransferTypes)

   423 		/**

   424 		@internalComponent

   425 		@released

   426 		*/

   427 		{

   428 		_LIT(KNote, "Public data is Not saved it just for Testing purposes to show the list of files got from the device!");

   429 		Log(LOG_LEVEL2, KNote);

   430 		RFileArray array;

   431 		CleanupClosePushL(array);

   432 		TInt length = iDriveList.Length();

   433 		TInt count = aTransferTypes.Count();

   434 		for (TInt driveCount = 0; driveCount < length && count; driveCount++)

   435 			{

   436 			if (iDriveList[driveCount])

   437 				{

   438 				for (TInt i =0; i < count; i++)

   439 					{

   440 					CBURActiveObject* active = CBURActiveObject::NewL();

   441 					CleanupStack::PushL(active);

   442 					iBackupClient->PublicFileListL(TDriveNumber(driveCount), *aTransferTypes[i], array, active->iStatus);

   443 					active->StartL();

   444 					User::LeaveIfError(active->Error());

   445 					CleanupStack::PopAndDestroy(active);

   446 					

   447 					TInt fileCount = array.Count();

   448 					_LIT(KFoundCount, "Found number of files: ");

   449 					LogWithNum(LOG_LEVEL3, KFoundCount, fileCount);

   450 					

   451 					for (TInt j = 0; j < fileCount; j++)

   452 						{

   453 						_LIT(KFile, "File: ");

   454 						LogWithText(LOG_LEVEL4, KFile, array[j].iName); 

   455 						}

   456 					

   457 					array.Reset();

   458 					}

   459 				}

   460 			}		

   461 		CleanupStack::PopAndDestroy(&array);

   462 		}

   463 	

   464 	void CBURTestStepBackupAsync::DoBackupL()

   465 		/**

   466 		Core backup method to carry out the transfer as well as the storage of 

   467 		data to the archive.

   468 		

   469 		@internalComponent

   470 		@released

   471 		

   472 		@param aDataType - Type of data to be backed up.

   473 		*/

   474 		{

   475 		if (iTransferTypes.Count())

   476 			{

   477 			// STEP 2 - Start the data request handler to backup data:

   478 			_LIT(KLog2, "Requesting backup data for IDs per drive...");

   479 			Log(LOG_LEVEL3, KLog2);

   480 			iDataTransferHandler->StartL();

   481 			// Log success:

   482 			if (iDataTransferHandler->Success())

   483 				{

   484 				_LIT(KLog3, "Operation finished with no errors");

   485 				Log(LOG_LEVEL3, KLog3);

   486 				} //if

   487 			else

   488 				{

   489 				iFailures++;

   490 				_LIT(KLog4, "Operation failed with errors ");

   491 				Log(LOG_LEVEL3, KLog4);

   492 				SetTestStepResult(TVerdict(EFail));

   493 				} //else

   494 			} //if 

   495 		else 

   496 			{

   497 			_LIT(KLogNoTrans, "Nothing to do ");

   498 			Log(LOG_LEVEL3, KLogNoTrans);

   499 			} //else

   500 		}

   501 		

   502 		

   503 	void CBURTestStepBackupAsync::DoActiveBackupL(TTransferDataType aTransferDataType)

   504 		/**

   505 		@internalComponent

   506 		@released

   507 		*/

   508 		{

   509 		RTransferTypeArray transferTypes;

   510 		GenerateSIDTransferTypesL(transferTypes, aTransferDataType);

   511 		if (transferTypes.Count())

   512 			{

   513 			TRAPD(error,

   514 			for (TInt i=0; i < KRetries;)

   515 				{

   516 				CheckSIDStatusL(transferTypes, iTransferTypes);													

   517 				if (iTransferTypes.Count()) // dataowners ready

   518 					{

   519 					DoBackupL();

   520 					} 

   521 				else if (transferTypes.Count()) // data owners not ready

   522 					{

   523 					User::After(KDelay);

   524 					i++;

   525 					}

   526 				else // finished with all sids

   527 					{

   528 					break;

   529 					}

   530 				} // for

   531 				); //TRAPD

   532 			if (transferTypes.Count())

   533 				{

   534 				iFailures++;

   535 				_LIT(KLogNoTrans, "***Error: Some Data Owners were Not Ready or Failed to Connect");

   536 				Log(LOG_LEVEL3, KLogNoTrans);

   537 				} //if

   538 			transferTypes.ResetAndDestroy();

   539 			

   540 			User::LeaveIfError(error);

   541 			}

   542 		else 

   543 			{

   544 			_LIT(KLogNoTrans, "Nothing to do ");

   545 			Log(LOG_LEVEL3, KLogNoTrans);

   546 			}

   547 

   548 		}

   549 		

   550 	void CBURTestStepBackupAsync::BackupJavaMidletsL()

   551 		/**

   552 		@internalComponent

   553 		@released

   554 		*/

   555 		{

   556 		_LIT(KMidlet, "Backup midlets...");

   557 		Log(LOG_LEVEL2, KMidlet);

   558 		GenerateJavaTransferTypesL(iTransferTypes, EJavaMIDlet);

   559 		DoBackupL();

   560 		}

   561 		

   562 	void CBURTestStepBackupAsync::BackupJavaMidletsDataL()

   563 		/**

   564 		@internalComponent

   565 		@released

   566 		*/

   567 		{

   568 		_LIT(KMidletData, "Backup midlets data...");

   569 		Log(LOG_LEVEL2, KMidletData);

   570 		GenerateJavaTransferTypesL(iTransferTypes, EJavaMIDletData);

   571 		DoBackupL();

   572 		}

   573 	

   574 	TVerdict CBURTestStepBackupAsync::doTestStepPostambleL()

   575 		/**

   576 		@return - TVerdict code

   577 		 Override of base class pure virtual

   578 		*/

   579 		{

   580 		_LIT(KLog, "Number of failures:");

   581 		LogWithNum(LOG_LEVEL3, KLog, iFailures);

   582 		if (iFailures)

   583 			{

   584 			SetTestStepResult(TVerdict(EFail));

   585 			}

   586 		return TestStepResult();

   587 		}

   588 	

   589 	}	// end namespace