1 // Copyright (c) 2005-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 // Tests CBaBackupSessionWrapper APIs and observers for backup server.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code

    22 */

    23 #include <eikenv.h>

    24 #include <coecntrl.h>

    25 #include <basched.h>

    26 #include <babackup.h>

    27 #include <eikappui.h>

    28 #include <eikdef.h>

    29 #include <eikapp.h>

    30 #include <eikdoc.h>

    31 #include <techview/eikon.hrh>

    32 #include <techview/eiktxlbx.h>

    33 #include <techview/eiktxlbm.h>

    34 #include <techview/eikchlst.h>

    35 #include <techview/eikclb.h>

    36 #include <techview/eikclbd.h>

    37 #include <techview/eikdialg.h>

    38 #include <techview/eikcapc.h>

    39 #include <apgwgnam.h>

    40 #include <apgtask.h>

    41 #include <apgcli.h>

    42 #include <eikcoctl.rsg>

    43 #include <techview/eikchkbx.h>

    44 #include <eikmsg.h>

    45 #include <techview/eikhopbt.h>

    46 #include <uiklafgt/eikcore.rsg>

    47 #include <ecom/ecom.h>

    48 

    49 

    50 #include "tbackup.hrh"

    51 #include <tbackup.rsg>

    52 

    53 

    54 #include "tbackup.h"

    55 

    56 _LIT(KBackupFile1,"foo1");

    57 _LIT(KBackupFile2,"foo2");

    58 _LIT(KBackupFile3,"foo3");

    59 _LIT(KObserverStr, "Observer %d:");

    60 _LIT(KBackupOpMsg, "Backup Operation running");

    61 _LIT(KRegistrationDlgTitle, "Register and DeRegister Observers");

    62 

    63 _LIT(KTBackupResourceFilePath, "z:\\system\\test\\tbackup\\tbackup.rsc");

    64 

    65 

    66 

    67 /**********************************************

    68  

    69  

    70  

    71  	CBackupDialogBase

    72  

    73  

    74  

    75 ************************************************/

    76 CBackupDialogBase::CBackupDialogBase(CDesCArray& aFiles,TOperationGranularity& aGranularity,TDes& aFileName)

    77 	: iFiles(aFiles), iGranularity(aGranularity), iFileName(aFileName)

    78 /**

    79    Constructor

    80  */

    81 	{}

    82 

    83 

    84 /**

    85    Auxiliary Function for all Test Cases

    86   

    87    This method is an override from CEikDialog.It performs pre-layout dialog

    88    initialisation.

    89   

    90  */

    91 void CBackupDialogBase::PreLayoutDynInitL()

    92 	{

    93 	SetHorOptionButListCurrentSet(EDlgBackupCloseOpButList,EDlgBackupCloseAll);

    94 	CEikChoiceList* list=static_cast<CEikChoiceList*>(Control(EDlgBackupFileList));

    95 	list->SetArrayExternalOwnership(ETrue);

    96 	list->SetArrayL(&iFiles);

    97 	UpdateFileListDimmedState();

    98 	}

    99 

   100 

   101 /**

   102    Auxiliary Function for all Test Cases

   103   

   104    This method is an override from CEikDialog. Handles dialog button press 'All'

   105    and 'File' to select a single file or all files to be closed by the dialog.

   106   

   107  */

   108 TBool CBackupDialogBase::OkToExitL(TInt /*aButtonId*/)

   109 	{

   110 	if (HorOptionButListCurrentSet(EDlgBackupCloseOpButList)==EDlgBackupCloseAll)

   111 		{

   112 		iGranularity=EAll;

   113 		}

   114 	else

   115 		{

   116 		iGranularity=ESingleFile;

   117 		const CEikChoiceList* list=static_cast<CEikChoiceList*>(Control(EDlgBackupFileList));

   118 		iFileName=iFiles[list->CurrentItem()];

   119 		}

   120 	return ETrue;

   121 	}

   122 

   123 /**

   124    Auxiliary Function for all Test Cases

   125   

   126    This method is an override from CEikDialog. This function is called when a

   127    control event of type EEventStateChanged is received by the dialog from one

   128    of its component controls. 

   129   

   130  */

   131 void CBackupDialogBase::HandleControlStateChangeL(TInt aControlId)

   132 	{

   133 	if (aControlId==EDlgBackupCloseOpButList)

   134 		{

   135 		UpdateFileListDimmedState();

   136 		}

   137 	}

   138 

   139 /**

   140    Auxiliary Function for all Test Cases

   141   

   142    This method is an override from CEikDialog. This method dims and deactivates

   143    the file choice list on the dialog.

   144   

   145  */

   146 void CBackupDialogBase::UpdateFileListDimmedState()

   147 	{

   148 	const TBool dimFileList=(HorOptionButListCurrentSet(EDlgBackupCloseOpButList)==EDlgBackupCloseAll);

   149 	const CEikChoiceList* list=static_cast<CEikChoiceList*>(Control(EDlgBackupFileList));

   150 	const TBool fileListDimmed=list->IsDimmed();

   151 	if (dimFileList!=fileListDimmed)

   152 		{

   153 		SetLineDimmedNow(EDlgBackupFileList,dimFileList);

   154 		}

   155 	}

   156 

   157 

   158 /**********************************************

   159  

   160  

   161  

   162  	CBackupCloseDialog

   163  

   164  

   165  

   166 ************************************************/

   167 

   168 /**

   169   Auxiliary function for TestCaseID tbackup-CmdCloseL

   170   

   171   This method initialises and launches the backup close dialog.

   172   

   173  */

   174 TBool CBackupCloseDialog::RunDlgLD(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,

   175 										TDes& aFileName,MBackupObserver::TFileLockFlags& aFlag)

   176 	{ // static

   177 	CBackupCloseDialog* dlg=new(ELeave) CBackupCloseDialog(aFiles,aGranularity,aFileName,aFlag);

   178 	return dlg->ExecuteLD(R_TBACKUP_FILE_OPTIONS);

   179 	}

   180 

   181 CBackupCloseDialog::CBackupCloseDialog(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,

   182 										TDes& aFileName,MBackupObserver::TFileLockFlags& aFlag)

   183 	: CBackupDialogBase(aFiles,aGranularity,aFileName), iFileFlag(aFlag)

   184 /**

   185    Constructor

   186  */

   187 	{

   188 	}

   189 /**

   190    Auxiliary function for TestCaseID tbackup-CmdCloseL

   191   

   192    This method is an override from CEikDialog.It performs pre-layout dialog

   193    initialisation.

   194   

   195  */

   196 void CBackupCloseDialog::PreLayoutDynInitL()

   197 	{

   198 	SetHorOptionButListCurrentSet(EDlgBackupFlagOpButList,EDlgBackupReadOnly);

   199 	CBackupDialogBase::PreLayoutDynInitL();

   200 	}

   201 

   202 /**

   203    Auxiliary function for TestCaseID tbackup-CmdCloseL

   204   

   205    This method is an override from CEikDialog. It is used to specify 'Read only' or

   206    'No access' file locks while CloseAll() & CloseFileL() APIs are invoked.

   207   

   208  */

   209 TBool CBackupCloseDialog::OkToExitL(TInt aButtonId)

   210 	{

   211 	if (HorOptionButListCurrentSet(EDlgBackupFlagOpButList)==EDlgBackupReadOnly)

   212 		{

   213 		iFileFlag=MBackupObserver::EReleaseLockReadOnly;

   214 		}

   215 	else

   216 		{

   217 		iFileFlag=MBackupObserver::EReleaseLockNoAccess;

   218 		}

   219 	return CBackupDialogBase::OkToExitL(aButtonId);

   220 	}

   221 

   222 

   223 /**********************************************

   224 

   225  

   226  

   227  	CBackupRestartDialog

   228  

   229  

   230  

   231 ************************************************/

   232 

   233 /**

   234    Auxiliary function for TestCaseID tbackup-CmdRestartL

   235   

   236    This method initialises and launches the backup restart dialog.

   237   

   238  */

   239 TBool CBackupRestartDialog::RunDlgLD(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,

   240 										TDes& aFileName)

   241 	{ // static

   242 	CBackupRestartDialog* dlg=new(ELeave) CBackupRestartDialog(aFiles,aGranularity,aFileName);

   243 	return dlg->ExecuteLD(R_TBACKUP_FILE_OPTIONS);

   244 	}

   245 

   246 CBackupRestartDialog::CBackupRestartDialog(CDesCArray& aFiles,CBackupDialogBase::TOperationGranularity& aGranularity,

   247 											TDes& aFileName)

   248 	: CBackupDialogBase(aFiles,aGranularity,aFileName)

   249 /**

   250    Constructor

   251  */

   252 	{}

   253 

   254 /**

   255    Auxiliary function for TestCaseID tbackup-CmdRestartL

   256   

   257    This method is an override from CEikDialog.It performs pre-layout dialog

   258    initialisation.

   259   

   260  */

   261 void CBackupRestartDialog::PreLayoutDynInitL()

   262 	{

   263 	SetTitleL(R_TBACKUP_RESTART_DLG_TITLE);

   264 	TBuf<20> text;

   265 	iCoeEnv->ReadResource(text,R_TBACKUP_RESTART_OPTION_TITLE);

   266 	CEikLabel* caption=Line(EDlgBackupCloseOpButList)->iCaption;

   267 	caption->SetTextL(text);

   268 	DeleteLine(EDlgBackupFlagOpButList);

   269 	CBackupDialogBase::PreLayoutDynInitL();

   270 	}

   271 

   272 

   273 

   274 /**********************************************

   275  

   276  

   277  

   278  	CBackupFileObserver

   279  

   280  

   281  

   282 ************************************************/

   283 CBackupFileObserver::TBackupFile::TBackupFile(const TDesC& aFileName,TFileLock aLockState)

   284 	: iFileName(aFileName), iLockState(aLockState)

   285 /**

   286    Constructor

   287  */

   288 	{}

   289 

   290 /**

   291    Auxiliary function for all test cases

   292   

   293    This method is part of two-phase construction of CBackupFileObserver.The

   294    method is called by CTBackupAppUi::CreateFileObserversL() to construct new

   295    client to backup server.

   296   

   297  */

   298 CBackupFileObserver* CBackupFileObserver::NewLC()

   299 	{ // static

   300 	CBackupFileObserver* self=new(ELeave) CBackupFileObserver();

   301 	CleanupStack::PushL(self);

   302 	self->ConstructL();

   303 	return self;

   304 	}

   305 

   306 CBackupFileObserver::~CBackupFileObserver()

   307 /**

   308    Destructor

   309  */

   310 	{

   311 	const TInt count=iBackupArray.Count();

   312 	for (TInt ii=count-1;ii>=0;ii--)

   313 		{

   314 		const TBackupFile& backup=iBackupArray[ii];

   315 		RemoveFile(backup.iFileName);

   316 		}

   317 	iBackupArray.Close();

   318 	delete iBackupSession;

   319 	}

   320 

   321 struct SFileAddCleanup

   322 	{

   323 	CBackupFileObserver* iFileObserver;

   324 	TFileName iFileName;

   325 	};

   326 

   327 /**

   328    Auxiliary function for all Test Cases

   329    

   330    This method is cleanup operation invoked by the pop and destroy action

   331    resulting from a subsequent call to CleanupStack::PopAndDestroy() to

   332    perform clean up of SFileAddCleanup object.

   333    

   334  */

   335 LOCAL_C void CleanupAddFile(TAny* aPtr)

   336 	{

   337 	SFileAddCleanup* cleanup=REINTERPRET_CAST(SFileAddCleanup*,aPtr);

   338 	cleanup->iFileObserver->RemoveFile(cleanup->iFileName);

   339 	}

   340 

   341 /**

   342    Auxiliary function for all Test Cases

   343    

   344    This method registers a file with the backup server.

   345    

   346  */

   347 void CBackupFileObserver::AddFileL(const TDesC& aFileName)

   348 	{

   349 	TBackupFile backup(aFileName,ELocked);

   350 	User::LeaveIfError(iBackupArray.Append(backup));

   351 	SFileAddCleanup cleanup;

   352 	cleanup.iFileObserver=this;

   353 	cleanup.iFileName=aFileName;

   354 	CleanupStack::PushL(TCleanupItem(CleanupAddFile,&cleanup));

   355 	iBackupSession->RegisterFileL(aFileName,*this);

   356 	CleanupStack::Pop(); // CleanupAddFile

   357 	}

   358 

   359 /**

   360    Auxiliary function for all Test Cases

   361    

   362    This method is invoked by cleanup method CleanupAddFile() to remove the

   363    registration of a file with the backup server.

   364    

   365  */

   366 void CBackupFileObserver::RemoveFile(const TDesC& aFileName)

   367 	{

   368 	const TInt index=Find(aFileName);

   369 	if (index!=KErrNotFound)

   370 		{

   371 		iBackupSession->DeregisterFile(aFileName);

   372 		iBackupArray.Remove(index);

   373 		iBackupArray.Compress();

   374 		}

   375 	}

   376 

   377 /**

   378    Auxiliary function for all Test Cases

   379    

   380    This method returns the array iBackupArray which holds the list of files

   381    registered with the observer.

   382    

   383  */

   384 const RArray<CBackupFileObserver::TBackupFile>& CBackupFileObserver::BackupArray() const

   385 	{

   386 	return iBackupArray;

   387 	}

   388 

   389 CBackupFileObserver::CBackupFileObserver()

   390 /**

   391    Constructor

   392  */

   393 	{}

   394 

   395 /**

   396    Auxiliary function for all test cases

   397   

   398    This method is part of Two-phase construction of CBackupFileObserver.The

   399    method constructs a new client to the backup server .

   400   

   401  */

   402 void CBackupFileObserver::ConstructL()

   403 	{

   404 	iBackupSession=CBaBackupSessionWrapper::NewL();

   405 	}

   406 

   407 /**

   408    Auxiliary function for all Test Cases

   409    

   410    This method attempts to find the file specifed within the iBackupArray

   411    and returns its index within the array if found. Otherwise KErrNotFound is

   412    returned.

   413    

   414  */

   415 TInt CBackupFileObserver::Find(const TDesC& aFileName) const

   416 	{

   417 	TInt index=KErrNotFound;

   418 	const TInt count=iBackupArray.Count();

   419 	for (TInt ii=0;ii<count;ii++)

   420 		{

   421 		const TBackupFile& backup=iBackupArray[ii];

   422 		if (backup.iFileName==aFileName)

   423 			{

   424 			index=ii;

   425 			break;

   426 			}

   427 		}

   428 	return index;

   429 	}

   430 

   431 /**

   432    Auxiliary function for all Test Cases

   433    

   434    This method finds the file specifed within the iBackupArray and changes its

   435    file lock as specified by aFlag parameter.

   436    

   437  */

   438 void CBackupFileObserver::ChangeFileLockL(const TDesC& aFileName,TFileLockFlags aFlags)

   439 	{

   440 	const TInt index=Find(aFileName);

   441 	if (index==KErrNotFound)

   442 		{

   443 		User::Invariant();

   444 		}

   445 	iBackupArray[index].iLockState=(CBackupFileObserver::TFileLock)aFlags;

   446 	}

   447 

   448 

   449 /**********************************************

   450  

   451  

   452   	CBackupOpeartionObserver

   453  

   454  

   455 ************************************************/

   456 

   457 /**

   458    Auxiliary function for all Test cases

   459    

   460    This method returns ETrue if the observer is registered with the backup

   461    server.

   462   

   463  */

   464 inline TBool CBackupOpeartionObserver::IsRegistered() const

   465 	{

   466 	return iRegistered;

   467 	}

   468 

   469 /**

   470    Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL

   471   

   472    The method sets the observer as registered with the back up server.

   473   

   474  */

   475 inline void CBackupOpeartionObserver::SetRegistered(TBool aIsRegistered)

   476 	{

   477 	iRegistered = aIsRegistered;

   478 	}

   479 

   480 /**

   481    Auxiliary function for all Test cases

   482    

   483    This method creates an observer for backup operation.

   484   

   485  */

   486 CBackupOpeartionObserver* CBackupOpeartionObserver::NewL()

   487 	{

   488 	CBackupOpeartionObserver* self=new(ELeave) CBackupOpeartionObserver();

   489 	return self;

   490 	}

   491 

   492 CBackupOpeartionObserver::CBackupOpeartionObserver()

   493 /**

   494    Constructor

   495  */

   496 	{

   497 	}

   498 

   499 /**

   500    Auxiliary function for TestCaseID tbackup-AutoUpdateBackupOperationStateL

   501   

   502    This method is an override from MBackupOperationObserver and is invoked when a

   503    backup or restore operation either starts or ends.

   504   

   505  */

   506 void CBackupOpeartionObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)

   507 	{

   508 	MBackupOperationObserver::TOperationType operation = aBackupOperationAttributes.iOperation;

   509 	switch (operation)

   510 		{

   511 		case MBackupOperationObserver::EStart:

   512 			User::InfoPrint(_L("Backup Operation Start"));

   513 			break;

   514 		case MBackupOperationObserver::EEnd:

   515 			User::InfoPrint(_L("Backup Operation End"));

   516 			break;

   517 		case MBackupOperationObserver::EAbort:

   518 			User::InfoPrint(_L("Backup Operation Abort"));

   519 			break;

   520 		case MBackupOperationObserver::ENone:

   521 		default:

   522 			break;

   523 		}

   524 	iBackupOperationAttributes = aBackupOperationAttributes;

   525 	}

   526 

   527 

   528 

   529 /**********************************************

   530  

   531  

   532  

   533  	CBackupOpeartionObserversWrapper

   534  

   535  

   536  

   537 ************************************************/

   538 

   539 

   540 /**

   541    Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL

   542   

   543    This method returns the number of backup observer object pointers stored in

   544    the pointer array iBackupOpeartionObserver.

   545   

   546  */

   547 inline TInt CBackupOpeartionObserversWrapper::CountObservers() const

   548 	{

   549 	return iBackupOpeartionObserver.Count();

   550 	}

   551 

   552 

   553 /**

   554    Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL

   555   

   556    This method returns the backup operation observer handle specified by

   557    aIndex from pointer array iBackupOpeartionObserver.

   558   

   559  */

   560 inline CBackupOpeartionObserver* CBackupOpeartionObserversWrapper::Observer(TInt aIndex)

   561 	{

   562 	return iBackupOpeartionObserver[aIndex];

   563 	}

   564 

   565 

   566 /**

   567    Auxiliary function for all Test Cases

   568   

   569    This method creates a wrapper for backup operation observers. The wrapper

   570    would contains number of observers as indicated by parameter

   571    aNumberOfObservers.

   572   

   573  */

   574 CBackupOpeartionObserversWrapper* CBackupOpeartionObserversWrapper::NewL(TInt aNumberOfObservers)

   575 	{

   576 	CBackupOpeartionObserversWrapper* self=new(ELeave) CBackupOpeartionObserversWrapper();

   577 	CleanupStack::PushL(self);

   578 	self->ConstructL(aNumberOfObservers);

   579 	CleanupStack::Pop(self);

   580 	return self;

   581 	}

   582 

   583 CBackupOpeartionObserversWrapper::~CBackupOpeartionObserversWrapper()

   584 /**

   585    Destructor

   586  */

   587 	{

   588 	ResetAndDestroy();

   589 	iBackupOpeartionObserver.Close();

   590 	delete iBackupSession;

   591 	}

   592 

   593 CBackupOpeartionObserversWrapper::CBackupOpeartionObserversWrapper()

   594 /**

   595    Constructor

   596  */

   597 	{

   598 	}

   599 

   600 /**

   601    Auxiliary function for all Test Cases

   602   

   603    This method creates 'aNumberOfObservers' of backup operation observers for

   604    the wrapper.

   605   

   606  */

   607 void CBackupOpeartionObserversWrapper::ConstructL(TInt aNumberOfObservers)

   608 	{

   609 	iBackupSession=CBaBackupSessionWrapper::NewL();

   610 	for (TInt counter=0; counter<aNumberOfObservers; ++counter)

   611 		{

   612 		User::LeaveIfError(iBackupOpeartionObserver.Append(CBackupOpeartionObserver::NewL()));

   613 		}

   614 	}

   615 

   616 /**

   617    Auxiliary function for TestCaseID tbackup-AutoUpdateBackupObserverRegistrationL

   618   

   619    The method registers the specified observer for notifications when a backup

   620    operation starts or ends and sets the observer as registered by calling

   621    CBackupOpeartionObserver::SetRegistered().

   622   

   623  */

   624 void CBackupOpeartionObserversWrapper::RegisterBackupOperationObserverL(CBackupOpeartionObserver& aBackupOpeartionObserver)

   625 	{

   626 	iBackupSession->RegisterBackupOperationObserverL(aBackupOpeartionObserver);

   627 	aBackupOpeartionObserver.SetRegistered(ETrue);

   628 	}

   629 

   630 /**

   631    Auxiliary function for all Test Cases

   632   

   633    The method de-registers the specified backup/restore observer and resets the

   634    iRegister flag of observer by calling

   635    CBackupOpeartionObserver::SetRegistered(). The method is invoked by

   636    CBackupOpeartionObserversWrapper::ResetAndDestroy() during destruction.

   637   

   638  */

   639 void CBackupOpeartionObserversWrapper::DeRegisterBackupOperationObserver(CBackupOpeartionObserver& aBackupOpeartionObserver)

   640 	{

   641 	iBackupSession->DeRegisterBackupOperationObserver(aBackupOpeartionObserver);

   642 	aBackupOpeartionObserver.SetRegistered(EFalse);

   643 	}

   644 

   645 /**

   646    Auxiliary function for all Test Cases

   647   

   648    This method is invoked by destructor to deregister all backup observers

   649    present in the wrapper. 

   650   

   651  */

   652 void CBackupOpeartionObserversWrapper::ResetAndDestroy()

   653 	{

   654 	const TInt count = iBackupOpeartionObserver.Count();

   655 	for (TInt index=0; index<count; ++index)

   656 		{

   657 		iBackupSession->DeRegisterBackupOperationObserver(*iBackupOpeartionObserver[index]);

   658 		}

   659 	iBackupOpeartionObserver.ResetAndDestroy();

   660 	iBackupOpeartionObserver.Close();

   661 	}

   662 

   663 /**********************************************

   664  

   665  

   666  

   667  	CBackupRegistrationDialog

   668  

   669  

   670  

   671 ************************************************/

   672 

   673 CBackupRegistrationDialog::CBackupRegistrationDialog(RPointerArray<CBackupOpeartionObserversWrapper>& aBackupOperationObserversWrapper)

   674 	: iBackupOperationObserversWrapper(aBackupOperationObserversWrapper)

   675 /**

   676    Constructor

   677  */

   678 	{

   679 	}

   680 

   681 /**

   682    Auxiliary Function tbackup-UpdateBackupObserverRegistrationL

   683   

   684    This method is an override from CEikDialog.It performs pre-layout dialog

   685    initialisation. The method finds whether all observers for each observer

   686    wrapper are registered and the state of each is displayed as a checkbox

   687    on the dialog.

   688   

   689  */

   690 void CBackupRegistrationDialog::PreLayoutDynInitL()

   691 	{

   692 	const TInt count = iBackupOperationObserversWrapper.Count();

   693 	CBackupOpeartionObserversWrapper* observerWrapper = NULL;

   694 	TInt previousCount = 0;

   695 	for (TInt index1=0; index1<count; ++index1)

   696 		{

   697 		observerWrapper = iBackupOperationObserversWrapper[index1];

   698 		const TInt count2 = observerWrapper->CountObservers();

   699 		for (TInt index2=0; index2<count2; ++index2)

   700 			{

   701 			CBackupOpeartionObserver* observer = observerWrapper->Observer(index2);

   702 			const TInt realIndex = previousCount+index2;

   703 			CEikCheckBox* checkBox = (CEikCheckBox*)Control(EObserversId+realIndex);

   704 			checkBox->SetState(observer->IsRegistered() ? CEikButtonBase::ESet : CEikButtonBase::EClear);

   705 			}

   706 		previousCount += count2;

   707 		}

   708 	}

   709 

   710 /**

   711    Auxiliary function for TestCaseID tbackup-UpdateBackupObserverRegistrationL

   712   

   713    This method is an override from CEikDialog. On click of OK button this

   714    method checks whether the check boxes that represent observers in each

   715    wrapper is set or reset and registers or deregisters the backup observer.

   716   

   717  */

   718 TBool CBackupRegistrationDialog::OkToExitL(TInt aButtonId)

   719 	{

   720 	if (aButtonId==EEikBidOk)

   721 		{

   722 		const TInt count = iBackupOperationObserversWrapper.Count();

   723 		CBackupOpeartionObserversWrapper* observerWrapper = NULL;

   724 		TInt previousCount = 0;

   725 		for (TInt index1=0; index1<count; ++index1)

   726 			{

   727 			observerWrapper = iBackupOperationObserversWrapper[index1];

   728 			const TInt count2 = observerWrapper->CountObservers();

   729 			for (TInt index2=0; index2<count2; ++index2)

   730 				{

   731 				CBackupOpeartionObserver* observer = observerWrapper->Observer(index2);

   732 				const TInt realIndex = previousCount+index2;

   733 				CEikCheckBox* checkBox = (CEikCheckBox*)Control(EObserversId+realIndex);

   734 				

   735 				const TBool stateSet = (checkBox->State()==CEikButtonBase::ESet);

   736 				const TBool previousState = observer->IsRegistered();

   737 				const TBool stateChanged = (!stateSet)!=(!previousState);

   738 				if (stateChanged)

   739 					{

   740 					if (stateSet)

   741 						{

   742 						observerWrapper->RegisterBackupOperationObserverL(*observer);

   743 						}

   744 					else

   745 						{

   746 						observerWrapper->DeRegisterBackupOperationObserver(*observer);

   747 						}

   748 					}

   749 				}

   750 			previousCount += count2;

   751 			}

   752 		}

   753 	return ETrue;

   754 	}

   755 

   756 

   757 /**********************************************

   758  

   759  

   760  

   761  	CBackupOperationDialog

   762  

   763  

   764  

   765 ************************************************/

   766 CBackupOperationDialog::CBackupOperationDialog(CBaBackupSessionWrapper& aBackupSession)

   767 	:iBackupSession(aBackupSession)

   768 /**

   769    Constructor

   770  */

   771 	{}

   772 

   773 /**

   774    Auxiliary function for TestCaseID tbackup-UpdateBackupOperationStateL

   775   

   776    This method is an override from CEikDialog.It performs pre-layout dialog

   777    initialisation. The method invokes 

   778    CBaBackupSessionWrapper::IsBackupOperationRunning() to find whether backup

   779    operation is in running and accordingly sets 'Start' & 'End' option buttons.

   780   

   781  */

   782 void CBackupOperationDialog::PreLayoutDynInitL()

   783 	{

   784 	CEikHorOptionButtonList* optionButtonList = (CEikHorOptionButtonList*)Control(EDlgBackupOperationSel);

   785 	const TBool isRunning = iBackupSession.IsBackupOperationRunning();

   786 	optionButtonList->SetButtonById(isRunning ? EDlgBackupOperationSel1 : EDlgBackupOperationSel2);

   787 	}

   788 

   789 /**

   790    Auxiliary function for TestCaseID tbackup-UpdateBackupOperationStateL

   791   

   792    This method is an override from CEikDialog. On click of OK button this

   793    method checks the state of option buttons labeled 'Start' & 'End'

   794    and accordingly starts / ends the backup operation by calling

   795    CBaBackupSessionWrapper::NotifyBackupOperationL().

   796   

   797  */

   798 TBool CBackupOperationDialog::OkToExitL(TInt aButtonId)

   799 	{

   800 	if (aButtonId==EEikBidOk)

   801 		{

   802 		CEikHorOptionButtonList* optionButtonList = (CEikHorOptionButtonList*)Control(EDlgBackupOperationSel);

   803 		const TInt labeledButtonId = optionButtonList->LabeledButtonId();

   804 		TBackupOperationAttributes backupOperationAttributes;

   805 		switch (labeledButtonId)

   806 			{

   807 		case EDlgBackupOperationSel1:

   808 			{

   809 			backupOperationAttributes.iFileFlag = MBackupObserver::EReleaseLockReadOnly;

   810 			backupOperationAttributes.iOperation = MBackupOperationObserver::EStart;

   811 			break;

   812 			}

   813 		case EDlgBackupOperationSel2:

   814 			{

   815 			backupOperationAttributes.iFileFlag = MBackupObserver::ETakeLock;

   816 			backupOperationAttributes.iOperation = MBackupOperationObserver::EEnd;

   817 			break;

   818 			}

   819 		default:

   820 			return EFalse;

   821 			}

   822 		iBackupSession.NotifyBackupOperationL(backupOperationAttributes);

   823 		}

   824 	return ETrue;

   825 	}

   826 

   827 

   828 /**********************************************

   829  

   830  

   831  

   832  	CBackdrop

   833  

   834  

   835  

   836 ************************************************/

   837 

   838 

   839 /**

   840    Auxiliary function for all Test Cases

   841   

   842    This method is part of Two - phase construction. It creates the background

   843    control.

   844   

   845  */

   846 CBackdrop* CBackdrop::NewL()

   847 	{ // static

   848 	CBackdrop* self=new(ELeave) CBackdrop();

   849 	CleanupStack::PushL(self);

   850 	self->CreateWindowL();

   851 	CleanupStack::Pop(); // self

   852 	return self;

   853 	}

   854 /**

   855    Auxiliary function for all Test Cases

   856   

   857    This method is an override from CCoeControl. It draws the background

   858    control.

   859   

   860  */

   861 void CBackdrop::Draw(const TRect& aRect) const

   862 	{

   863 	CWindowGc& gc=SystemGc();

   864 	gc.SetPenStyle(CGraphicsContext::ESolidPen);

   865 	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   866 	gc.SetPenColor(KRgbGreen);

   867 	gc.SetBrushColor(KRgbGreen);

   868 	gc.DrawRect(aRect);

   869 	}

   870 

   871 

   872 /**********************************************

   873  

   874  

   875  

   876  	COpenAppList

   877  

   878  

   879  

   880 ************************************************/

   881 

   882 /**

   883    Auxiliary function for TestCaseID tbackup-CmdListAppsL

   884   

   885    This method creates a client session with the windows server and retrieves

   886    the window group list currently available. The caption or the thread id for

   887    each of window groups from the list is obtained and added to the list box.

   888   

   889  */

   890 void COpenAppList::UpdateL()

   891 	{

   892 	RWsSession& wsSession=iEikonEnv->WsSession();

   893 	TInt count=wsSession.NumWindowGroups(0);

   894 	if (!count)

   895 		return;

   896 	CDesCArray* tasks=new(ELeave) CDesCArrayFlat(count);

   897 	CleanupStack::PushL(tasks);

   898 	CArrayFixFlat<TInt>* wgIds=new(ELeave) CArrayFixFlat<TInt>(count);

   899 	CleanupStack::PushL(wgIds);

   900 	CApaWindowGroupName* wgName=CApaWindowGroupName::NewLC(wsSession);

   901 	wsSession.WindowGroupList(0,wgIds);

   902 	TBuf<2*KMaxFileName+1> name;

   903 	const TInt wgCount=wgIds->Count();

   904 	for (TInt ii=0;ii<wgCount;ii++)

   905 		{ 

   906 		const TInt wgId=(*wgIds)[ii];

   907 		wgName->ConstructFromWgIdL(wgId);

   908 		TPtrC caption=wgName->Caption();

   909 		if(wgName->Hidden())

   910 			{

   911 			continue;

   912 			}

   913 		else if (caption.Length()==0) // not set yet - use thread name instead

   914 			{

   915 			TThreadId threadId;

   916 			TInt err=wsSession.GetWindowGroupClientThreadId(wgId,threadId);

   917 			if (err==KErrNone)

   918 				{

   919 				RThread thread;

   920 				err=thread.Open(threadId);

   921 				if (err==KErrNone)

   922 					{

   923 					name.Copy(thread.Name());

   924 					thread.Close();

   925 					}

   926 				}

   927 			if (err!=KErrNone)

   928 				name.Copy(_L("???"));

   929 			}

   930 		else

   931 			{

   932 			name=caption;

   933 			name.Append(' ');

   934 			TFileName docName=wgName->DocName();

   935 			name.Append(docName);

   936 			}

   937 		tasks->AppendL(name);

   938 		}

   939 	CleanupStack::PopAndDestroy(2); // wgIds, wgName

   940 	Model()->SetItemTextArray(tasks);

   941 	CleanupStack::Pop(); // tasks

   942 	HandleItemAdditionL();

   943 	}

   944 

   945 /**********************************************

   946  

   947   

   948  	COpenFileList

   949  

   950  

   951  

   952 ************************************************/

   953 

   954 COpenFileList::COpenFileList(CArrayPtr<CBackupFileObserver>& aFileObservers)

   955 	: iFileObservers(aFileObservers)

   956 /**

   957    Constructor

   958  */

   959 	{}

   960 

   961 COpenFileList::~COpenFileList()

   962 /**

   963    Destructor

   964  */

   965 	{

   966 	delete iList;

   967 	}

   968 

   969 /**

   970    Auxiliary function for all Test Cases

   971   

   972    The method creates a Column List Box and sets the width for all the

   973    columns in the list box.

   974   

   975  */

   976 void COpenFileList::ConstructL()

   977 	{

   978 	CreateWindowL();

   979 	iList=new(ELeave) CEikColumnListBox();

   980 	iList->ConstructL(this);

   981 	CColumnListBoxData* columnData=iList->ItemDrawer()->ColumnData();

   982 	// following assumes a know width for this control

   983 	// bad practise but not worth writing a scalable control in this test app

   984 	columnData->SetColumnWidthPixelL(0,20);

   985 	columnData->SetColumnWidthPixelL(1,180);

   986 	columnData->SetColumnWidthPixelL(2,100);

   987 	}

   988 

   989 /**

   990    Auxiliary function for TestCaseID tbackup_CmdListOpenFilesL

   991   

   992    This method lists filename and lock state of all files associated with the

   993    file observers.

   994   

   995  */

   996 void COpenFileList::UpdateL()

   997 	{

   998 	CDesCArray* textArray=new(ELeave) CDesCArrayFlat(2);

   999 	CleanupStack::PushL(textArray);

  1000 	TChar separator(KColumnListSeparator);

  1001 	const TInt obsCount=iFileObservers.Count();

  1002 	for (TInt ii=0;ii<obsCount;ii++)

  1003 		{

  1004 		TBuf<2> num;

  1005 		num.Num(ii);

  1006 		const RArray<CBackupFileObserver::TBackupFile>& backupArray=iFileObservers[ii]->BackupArray();

  1007 		const TInt fileCount=backupArray.Count();

  1008 		for (TInt jj=0;jj<fileCount;jj++)

  1009 			{

  1010 			TBuf<300> buf;

  1011 			buf.Append(num);

  1012 			const CBackupFileObserver::TBackupFile& backupFile=backupArray[jj];

  1013 			buf.Append(separator);

  1014 			buf.Append(backupFile.iFileName);

  1015 			buf.Append(separator);

  1016 			TBuf<20> lockState;

  1017 			if (backupFile.iLockState==CBackupFileObserver::ELocked)

  1018 				{

  1019 				iCoeEnv->ReadResource(lockState,R_TBACKUP_LOCKSTATE_LOCKED);

  1020 				}

  1021 			else if (backupFile.iLockState==CBackupFileObserver::EReadOnly)

  1022 				{

  1023 				iCoeEnv->ReadResource(lockState,R_TBACKUP_LOCKSTATE_READONLY);

  1024 				}

  1025 			else if(backupFile.iLockState==CBackupFileObserver::ENoAccess)

  1026 				{

  1027 				iCoeEnv->ReadResource(lockState,R_TBACKUP_LOCKSTATE_NOACCESS);

  1028 				}

  1029 			else

  1030 				{

  1031 				lockState=_L("???");

  1032 				}

  1033 			buf.Append(lockState);

  1034 			textArray->AppendL(buf);

  1035 			}

  1036 		}

  1037 	iList->Model()->SetItemTextArray(textArray);

  1038 	CleanupStack::Pop(); // textArray

  1039 	iList->HandleItemAdditionL();

  1040 	}

  1041 

  1042 /**

  1043    Auxiliary function for all Test Cases

  1044   

  1045    The method is an override from CCoeControl. It returns minimum required

  1046    size of column list box.

  1047   

  1048  */

  1049 TSize COpenFileList::MinimumSize()

  1050 	{

  1051 	return iList->MinimumSize();

  1052 	}

  1053 

  1054 /**

  1055    Auxiliary function for all Test Cases

  1056   

  1057    The method is an override from CCoeControl. It is invoked to set the size

  1058    and position of the content of list box control.

  1059   

  1060  */

  1061 void COpenFileList::SizeChanged()

  1062 	{

  1063 	const TRect rect(Rect());

  1064 	iList->SetRect(rect);

  1065 	}

  1066 

  1067 /**

  1068    Auxiliary function for all Test Cases

  1069   

  1070    The method is an override from CCoeControl. It returns the number of

  1071    controls contained in the compound control COpenFileList.

  1072   

  1073  */

  1074 TInt COpenFileList::CountComponentControls() const

  1075 	{

  1076 	return 1;

  1077 	}

  1078 

  1079 /**

  1080    Auxiliary function for all Test Cases

  1081   

  1082    The method is an override from CCoeControl. It returns the handle to list

  1083    box present on compound control COpenFileList.  

  1084   

  1085  */

  1086 CCoeControl* COpenFileList::ComponentControl(TInt aIndex) const

  1087 	{

  1088 	if (aIndex==0)

  1089 		{

  1090 		return iList;

  1091 		}

  1092 	return NULL;

  1093 	}

  1094 

  1095 

  1096 /**********************************************

  1097  

  1098  

  1099  

  1100  	CTBackupAppUi

  1101  

  1102  

  1103  

  1104 ************************************************/

  1105 

  1106 CTBackupAppUi::CTBackupAppUi(CTmsTestStep* aStep) :

  1107 	CTestAppUi(aStep, KTBackupResourceFilePath)//,		R_TBACKUP_HOTKEYS, R_TBACKUP_MENUBAR, R_TBACKUP_TOOLBAR)

  1108 /**

  1109    Constructor

  1110  */

  1111 	{

  1112 	}

  1113 /**

  1114    Auxiliary function for all Test Cases

  1115    

  1116    This method creates a client interface to the backup server and performs the

  1117    following:

  1118    (a) Creates a background control.

  1119    (b) Creates backup observers and adds files to the observer.

  1120    (c) Creates an Application List from window groups.

  1121    (d) Creates a list for files attached to the observers.

  1122    

  1123  */

  1124 void CTBackupAppUi::ConstructL()

  1125 	{

  1126 	CTestAppUi::ConstructL();

  1127 	iEikonEnv->SetSystem(ETrue);

  1128 	iBackupSession=CBaBackupSessionWrapper::NewL();

  1129 

  1130 	CreateBackgroundL();

  1131 	CreateFileObserversL();

  1132 	CreateAppListL();

  1133 	CreateFileListL();

  1134 	CreateObserversListL();

  1135 	iBusyMsg = new (ELeave) CEikBusyMsgWin(*iEikonEnv);