1 // Copyright (c) 2001-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 //

    15 

    16 #include "../TestSyncPlugIn/cntsyncchecker.h"

    17 #include "../TestSyncPlugIn/cntsyncdata.h"

    18 #include "../TestSyncPlugIn/cntsyncphonedata.h"

    19 

    20 #include <cntdef.h>

    21 #include <cntdb.h>

    22 

    23 #include <centralrepository.h>  // CRepository.

    24 #include <e32property.h>

    25 #include <phbksync.h>

    26 

    27 class CContactSyncPhonebookData;

    28 class CPhonebookContact;

    29 

    30 

    31 

    32 

    33 

    34 EXPORT_C CContactSyncChecker* CContactSyncChecker::NewL()

    35 	{

    36 	CContactSyncChecker* self = new(ELeave) CContactSyncChecker();

    37 	return self;

    38 	}

    39 	

    40 	

    41 

    42 EXPORT_C CContactSyncChecker::~CContactSyncChecker()	

    43 	{

    44 	//TRAP_IGNORE(ResetL() );

    45 	}

    46 

    47 EXPORT_C TInt CContactSyncChecker::ValidateResponseL(MContactSynchroniser::TValidateOperation aOp)

    48 	{

    49 

    50 	CContactSyncData* temp = CContactSyncData::NewL();

    51 	CleanupStack::PushL(temp);

    52 	CContactSyncData& settings = temp->DataL();

    53 	TInt ret;

    54 	switch (aOp)

    55 		{

    56 	case MContactSynchroniser::ERead:

    57 		ret = settings.iReadValidateResponse;

    58 		break;

    59 	case MContactSynchroniser::ESearch:

    60 		ret = settings.iSearchValidateResponse;

    61 		break;

    62 	case MContactSynchroniser::EEdit:

    63 		ret = settings.iEditValidateResponse;

    64 		break;

    65 	default:

    66 		ret = KErrNone;

    67 		break;

    68 		}

    69 	CleanupStack::PopAndDestroy(temp);

    70 	return ret;

    71 	}

    72 

    73 EXPORT_C TInt CContactSyncChecker::ValidateWriteResponseL()

    74 	{

    75 	CContactSyncData* temp = CContactSyncData::NewL();

    76 	CleanupStack::PushL(temp);

    77 	CContactSyncData& settings = temp->DataL();

    78 	TInt ret(settings.iValidateWriteResponse);

    79 	CleanupStack::PopAndDestroy(temp);

    80 	return ret;

    81 	}

    82 

    83 EXPORT_C TInt CContactSyncChecker::DeleteContactResponseL()

    84 	{

    85 	CContactSyncData* temp = CContactSyncData::NewL();

    86 	CleanupStack::PushL(temp);

    87 	CContactSyncData& settings = temp->DataL();

    88 	TInt ret(settings.iDeleteContactResponse);

    89 	CleanupStack::PopAndDestroy(temp);

    90 	return ret;

    91 	}

    92 

    93 EXPORT_C TContactItemId CContactSyncChecker::ICCTemplateIdL(TUid aPhonebookUid)

    94 	{

    95 	CContactSyncData* temp = CContactSyncData::NewL();

    96 	CleanupStack::PushL(temp);

    97 	CContactSyncData& settings = temp->DataL();

    98 	TContactItemId ret = KNullContactId;

    99 	CContactSyncPhonebookData* tempData = settings.PhonebookData(aPhonebookUid);	

   100 	if (tempData)

   101 		{

   102 		ret = tempData->TemplateId();

   103 		}

   104 	CleanupStack::PopAndDestroy(temp);

   105 	return ret;

   106 	}

   107 

   108 EXPORT_C TContactItemId CContactSyncChecker::GroupIdL(TUid aPhonebookUid)

   109 	{

   110 	CContactSyncData* temp = CContactSyncData::NewL();

   111 	CleanupStack::PushL(temp);

   112 	CContactSyncData& settings = temp->DataL();

   113 	TContactItemId ret = KNullContactId;

   114 	CContactSyncPhonebookData* tempData = settings.PhonebookData(aPhonebookUid);	

   115 	if (tempData)

   116 		{

   117 		ret = tempData->GroupId();

   118 		}

   119 	CleanupStack::PopAndDestroy(temp);

   120 	return ret;

   121 	}

   122 

   123 EXPORT_C TUid CContactSyncChecker::PhonebookUidL(TContactItemId aTemplateId)

   124 	{

   125 	CContactSyncData* temp = CContactSyncData::NewL();

   126 	CleanupStack::PushL(temp);

   127 	CContactSyncData& settings = temp->DataL();

   128 	TUid ret = KUidIccPhonebookNotFound;

   129 	CContactSyncPhonebookData* tempData = settings.PhonebookDataFromTemplateId(aTemplateId);	

   130 	if (tempData)

   131 		{

   132 		ret = tempData->PhonebookUid();

   133 		}

   134 	CleanupStack::PopAndDestroy(temp);

   135 	return ret;

   136 	}

   137 	

   138 EXPORT_C void CContactSyncChecker::ResetEverythingL()

   139 	{

   140 	CContactSyncData* temp = CContactSyncData::NewL();

   141 	CleanupStack::PushL(temp);

   142 	CContactSyncData& settings = temp->DataL();

   143 	// all Validate Responses set to an error

   144 	settings.ResetCallCountAndValidateResponsesL();

   145 	// delete all phonebooks

   146 	settings.DeleteAllPhonebooks();

   147 	settings.WriteConfigurationDataL();	

   148 	CleanupStack::PopAndDestroy(temp);

   149 	}

   150 	

   151 /**

   152  Current count of Phonebook Synch State change notifications outstanding - for all phonebooks

   153  (Note this is across all Views using the test DLL.)

   154  */

   155 EXPORT_C TInt CContactSyncChecker::TotalNotificationPendingCountL()

   156 	{

   157 	CContactSyncData* temp = CContactSyncData::NewL();

   158 	CleanupStack::PushL(temp);

   159 	CContactSyncData& settings = temp->DataL();

   160 	RPointerArray<CContactSyncPhonebookData>& perPhbkData = settings.PerPhonebookData();

   161 	const TInt phbkCount = perPhbkData.Count();

   162 	TInt total = 0;

   163 

   164 	for (TInt k = 0; k < phbkCount; ++k)

   165 		{

   166 		total += perPhbkData[k]->NotificationPendingCount();

   167 		}

   168 	CleanupStack::PopAndDestroy(temp);

   169 	return total;

   170 	}

   171 

   172 EXPORT_C void CContactSyncChecker::SetValidateResponseL(MContactSynchroniser::TValidateOperation aOp, TInt aError)

   173 	{

   174 	CContactSyncData* temp = CContactSyncData::NewL();

   175 	CleanupStack::PushL(temp);

   176 	CContactSyncData& settings = temp->DataL();

   177 	switch (aOp)

   178 		{

   179 	case MContactSynchroniser::ERead:

   180 		settings.iReadValidateResponse=aError;

   181 		break;

   182 	case MContactSynchroniser::ESearch:

   183 		settings.iSearchValidateResponse=aError;

   184 		break;

   185 	case MContactSynchroniser::EEdit:

   186 		settings.iEditValidateResponse=aError;

   187 		break;

   188 	default:

   189 		break;

   190 		}

   191 	settings.WriteConfigurationDataL();	

   192 	CleanupStack::PopAndDestroy(temp);

   193 	}

   194 

   195 EXPORT_C void CContactSyncChecker::SetValidateWriteResponseL(TInt aError)

   196 	{

   197 	CContactSyncData* temp = CContactSyncData::NewL();

   198 	CleanupStack::PushL(temp);

   199 	CContactSyncData& settings = temp->DataL();

   200 	settings.iValidateWriteResponse=aError;

   201 	settings.WriteConfigurationDataL();	

   202 	CleanupStack::PopAndDestroy(temp);

   203 	}

   204 

   205 EXPORT_C void CContactSyncChecker::SetDeleteContactResponseL(TInt aError)

   206 	{

   207 	CContactSyncData* temp = CContactSyncData::NewL();

   208 	CleanupStack::PushL(temp);

   209 	CContactSyncData& settings = temp->DataL();

   210 	settings.iDeleteContactResponse=aError;

   211 	settings.WriteConfigurationDataL();	

   212 	CleanupStack::PopAndDestroy(temp);

   213 	}

   214 

   215 EXPORT_C void CContactSyncChecker::SetPhonebookEntryL(TUid /*aPhonebookUid*/,TInt /*aPhonebookTemplateId*/,TInt /*aPhonebookGroupId*/)

   216 	{

   217 /*	TLookupPhonebookEntry phonebookEntry(aPhonebookUid,aPhonebookTemplateId,aPhonebookGroupId);

   218 	CContactSyncData* temp = CContactSyncData::NewL();

   219 	CleanupStack::PushL(temp);

   220 	CContactSyncData& settings = temp->DataL();

   221 	settings.iPhonebookEntries.Append(phonebookEntry);

   222 	settings.WriteConfigurationDataL();	

   223 	CleanupStack::PopAndDestroy(temp);*/

   224 	}

   225 	

   226 EXPORT_C TInt CContactSyncChecker::UpdatePhonebookEntryL(TUid aPhonebookUid, TInt aPhonebookTemplateId, TInt aPhonebookGroupId)

   227 	{

   228 	CContactSyncData* temp = CContactSyncData::NewL();

   229 	CleanupStack::PushL(temp);

   230 	CContactSyncData& settings = temp->DataL();

   231 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   232 	TInt ret = KErrNotFound;

   233 	if (phbkData)

   234 		{

   235 		phbkData->SetTemplateId(aPhonebookTemplateId);

   236 		phbkData->SetGroupId(aPhonebookGroupId);

   237 		ret = KErrNone;

   238 		}

   239 	settings.WriteConfigurationDataL();	

   240 	CleanupStack::PopAndDestroy(temp);

   241 

   242 	return ret;

   243 	}

   244 

   245 

   246 EXPORT_C void CContactSyncChecker::EnableVerboseLoggingL()

   247 	{

   248 	CContactSyncData* temp = CContactSyncData::NewL();

   249 	CleanupStack::PushL(temp);

   250 	CContactSyncData& settings = temp->DataL();

   251 	settings.iVerboseLoggingEnabled=ETrue;

   252 	settings.WriteConfigurationDataL();	

   253 	CleanupStack::PopAndDestroy(temp);

   254 	}

   255 

   256 EXPORT_C TBool CContactSyncChecker::VerboseLoggingEnabledL()

   257 	{

   258 	CContactSyncData* temp = CContactSyncData::NewL();

   259 	CleanupStack::PushL(temp);

   260 	CContactSyncData& settings = temp->DataL();

   261 	TBool ret = settings.iVerboseLoggingEnabled;

   262 	CleanupStack::PopAndDestroy(temp);

   263 	return ret;

   264 	}

   265 

   266 EXPORT_C void CContactSyncChecker::SyncMethodCalledL()

   267 	{

   268 	CContactSyncData* temp = CContactSyncData::NewL();

   269 	CleanupStack::PushL(temp);

   270 	CContactSyncData& settings = temp->DataL();

   271 	settings.iSyncCallCount++;

   272 	settings.WriteConfigurationDataL();	

   273 	CleanupStack::PopAndDestroy(temp);

   274 	}

   275 	

   276 

   277 

   278 EXPORT_C void CContactSyncChecker::ValidateMethodCalledL()

   279 	{

   280 	CContactSyncData* temp = CContactSyncData::NewL();

   281 	CleanupStack::PushL(temp);

   282 	CContactSyncData& settings = temp->DataL();

   283 	settings.iValidateCallCount++;

   284 	settings.WriteConfigurationDataL();	

   285 	CleanupStack::PopAndDestroy(temp);

   286 	}

   287 

   288 EXPORT_C void CContactSyncChecker::ResetMethodCallCountsL()

   289 	{

   290 	CContactSyncData* temp = CContactSyncData::NewL();

   291 	CleanupStack::PushL(temp);

   292 	CContactSyncData& settings = temp->DataL();

   293 	settings.iSyncCallCount = 0;

   294 	settings.iValidateCallCount = 0;

   295 	settings.WriteConfigurationDataL();	

   296 	CleanupStack::PopAndDestroy(temp);

   297 	}

   298 	

   299 EXPORT_C void CContactSyncChecker::PluginLoadedL()

   300     {

   301 	CContactSyncData* temp = CContactSyncData::NewL();

   302 	CleanupStack::PushL(temp);

   303 	CContactSyncData& settings = temp->DataL();

   304 	settings.iPluginCallCount++;

   305 	settings.WriteConfigurationDataL();	

   306 	CleanupStack::PopAndDestroy(temp);

   307     }

   308     

   309 EXPORT_C void CContactSyncChecker::PluginUnloadedL()

   310     {

   311 	CContactSyncData* temp = CContactSyncData::NewL();

   312 	CleanupStack::PushL(temp);

   313 	CContactSyncData& settings = temp->DataL();

   314 	settings.iPluginCallCount--;

   315 	settings.WriteConfigurationDataL();	

   316 	CleanupStack::PopAndDestroy(temp);

   317     }

   318 

   319 EXPORT_C TInt CContactSyncChecker::ValidateMethodCallCountL()

   320 	{

   321 	TInt ret;

   322 	CContactSyncData* temp = CContactSyncData::NewL();

   323 	CleanupStack::PushL(temp);

   324 	CContactSyncData& settings = temp->DataL();

   325 	ret = settings.iValidateCallCount;

   326 	CleanupStack::PopAndDestroy(temp);

   327 	return ret;

   328 	}

   329 

   330 EXPORT_C TInt CContactSyncChecker::SyncMethodCallCountL()

   331 	{

   332 	TInt ret;

   333 	CContactSyncData* temp = CContactSyncData::NewL();

   334 	CleanupStack::PushL(temp);

   335 	CContactSyncData& settings = temp->DataL();

   336 	ret = settings.iSyncCallCount;

   337 	CleanupStack::PopAndDestroy(temp);

   338 	return ret;

   339 	}

   340 	

   341 EXPORT_C TInt CContactSyncChecker::PluginLoadedCountL()

   342     {

   343 	CContactSyncData* temp = CContactSyncData::NewL();

   344 	CleanupStack::PushL(temp);

   345 	CContactSyncData& settings = temp->DataL();

   346 	TInt ret = settings.iPluginCallCount;

   347 	CleanupStack::PopAndDestroy(temp);

   348 	return ret;

   349     }

   350 

   351 EXPORT_C void CContactSyncChecker::ResetL()

   352 	{

   353 	CContactSyncData* temp = CContactSyncData::NewL();

   354 	CleanupStack::PushL(temp);

   355 	temp->WriteConfigurationDataL();

   356 	CleanupStack::PopAndDestroy(temp);

   357 	}

   358 

   359 

   360 EXPORT_C void CContactSyncChecker::SetSynchronisedL(TBool aIsSynchronised, TUid aPhonebookUid)

   361 	{

   362 	CContactSyncData* temp = CContactSyncData::NewL();

   363 	CleanupStack::PushL(temp);

   364 	CContactSyncData& settings = temp->DataL();

   365 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   366 	if (!phbkData)

   367 		{

   368 		User::Invariant();

   369 		}

   370 	phbkData->SetSynchronised(aIsSynchronised);

   371 	settings.WriteConfigurationDataL();	

   372 	CleanupStack::PopAndDestroy(temp);

   373 	}

   374 

   375 EXPORT_C TBool CContactSyncChecker::IsSynchronisedL(TUid aPhonebookUid)

   376 	{

   377 	CContactSyncData* temp = CContactSyncData::NewL();

   378 	CleanupStack::PushL(temp);

   379 	CContactSyncData& settings = temp->DataL();

   380 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   381 	if (!phbkData)

   382 		{

   383 		User::Leave(KErrNotSupported);

   384 		}

   385 	TBool ret = phbkData->IsSynchronisedL();;

   386 	CleanupStack::PopAndDestroy(temp);

   387 	return ret;

   388 	}

   389 

   390 

   391 

   392 

   393 

   394  EXPORT_C void CContactSyncChecker::StoreNotificationRequestL(TRequestStatus& aStatus, TUid aPhonebookUid)

   395  	{

   396 	RProperty property;

   397  	CContactSyncData* temp = CContactSyncData::NewL();

   398  	CleanupStack::PushL(temp);

   399  	CContactSyncData& settings = temp->DataL();

   400  	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   401 	TInt error(KErrNone);

   402 	if (!phbkData)

   403 		{

   404 		error = KErrNotSupported;

   405 		}

   406 	else

   407 		{

   408 		aStatus=KRequestPending;

   409 		//Store any value, the value does not mean anything, the reason is to let the vector grow

   410 		phbkData->StoreNotificationRequest(100);

   411  		settings.WriteConfigurationDataL();

   412 	 	// Define a property using Publish and Subscribe.

   413 	    RProperty::Define(

   414 	    	SyncNotification::KPropertyCategory, //Category

   415 	        aPhonebookUid.iUid, //key

   416 	        RProperty::EInt); //Attr

   417  

   418 		// Subscribe for the dst event

   419 		User::LeaveIfError(property.Attach(SyncNotification::KPropertyCategory,aPhonebookUid.iUid));

   420 		property.Subscribe(aStatus);

   421 		User::After(1000);	

   422 		}

   423 	// some problem encountered

   424 	if (error)

   425 		{

   426 		TRequestStatus* pS = &aStatus;

   427 		User::RequestComplete(pS, error);

   428 		}

   429  	CleanupStack::PopAndDestroy(temp);

   430  	}

   431  

   432  EXPORT_C void CContactSyncChecker::CompleteNotificationRequestL(TInt aError, TUid aPhonebookUid)

   433  	{

   434  	CContactSyncData* temp = CContactSyncData::NewL();

   435  	CleanupStack::PushL(temp);

   436  	CContactSyncData& settings = temp->DataL();

   437   	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   438 	if (!phbkData)

   439 		{

   440 		User::Invariant();

   441 		}

   442 	phbkData->CompleteNotificationRequest(aError);			

   443 	settings.WriteConfigurationDataL();	

   444  	CleanupStack::PopAndDestroy(temp);

   445  	}

   446  

   447 EXPORT_C TInt CContactSyncChecker::FetchNotificationErrorL(TUid aPhoneBookUid)

   448 	{

   449  	CContactSyncData* temp = CContactSyncData::NewL();

   450  	CleanupStack::PushL(temp);

   451  	CContactSyncData& settings = temp->DataL();

   452   	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhoneBookUid);

   453 	if (!phbkData)

   454 		{

   455 		User::Invariant();

   456 		}

   457 	TInt ret = phbkData->ErrorCode();

   458 	CleanupStack::PopAndDestroy(temp);

   459 	return ret;

   460 	}	

   461 

   462 EXPORT_C TInt CContactSyncChecker::NotificationPendingCountL(TUid aPhonebookUid)

   463 /**

   464  * Current count of Phonebook Synch State change notifications outstanding

   465  * (Note this is across all Views using the test DLL.)

   466  */

   467 	{

   468 	CContactSyncData* temp = CContactSyncData::NewL();

   469 	CleanupStack::PushL(temp);

   470 	CContactSyncData& settings = temp->DataL();

   471   	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   472 	if (!phbkData)

   473 		{

   474 		User::Invariant();

   475 		}

   476 

   477 	TInt ret = phbkData->NotificationPendingCount();

   478 	CleanupStack::PopAndDestroy(temp);

   479 	return ret;

   480 	}

   481 

   482 

   483 EXPORT_C void CContactSyncChecker::SetSynchronisedLeaveCodeL(TInt aLeave, TUid aPhonebookUid)

   484 	{

   485 	CContactSyncData* temp = CContactSyncData::NewL();

   486 	CleanupStack::PushL(temp);

   487 	CContactSyncData& settings = temp->DataL();

   488   	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   489 	if (!phbkData)

   490 		{

   491 		User::Invariant();

   492 		}

   493 	phbkData->SetSynchronisedLeaveCode(aLeave);

   494 	settings.WriteConfigurationDataL();	

   495 	CleanupStack::PopAndDestroy(temp);

   496 	}

   497 

   498 

   499 EXPORT_C TInt CContactSyncChecker::UpdatePhonebookTemplateIdL(TUid aPhonebookUid, TInt aPhonebookTemplateId)

   500 	{

   501 	CContactSyncData* temp = CContactSyncData::NewL();

   502 	CleanupStack::PushL(temp);

   503 	CContactSyncData& settings = temp->DataL();

   504 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   505 	TInt ret = KErrNotFound;

   506 	if (phbkData)

   507 		{

   508 		phbkData->SetTemplateId(aPhonebookTemplateId);

   509 		ret = KErrNone;

   510 		}

   511 	settings.WriteConfigurationDataL();	

   512 	CleanupStack::PopAndDestroy(temp);

   513 	return ret;

   514 	}

   515 	

   516 EXPORT_C TInt CContactSyncChecker::UpdatePhonebookGroupIdL(TUid aPhonebookUid, TInt aPhonebookGroupId)

   517 	{

   518 	CContactSyncData* temp = CContactSyncData::NewL();

   519 	CleanupStack::PushL(temp);

   520 	CContactSyncData& settings = temp->DataL();

   521 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   522 	TInt ret = KErrNotFound;

   523 

   524 	if (phbkData)

   525 		{

   526 		phbkData->SetGroupId(aPhonebookGroupId);

   527 		ret = KErrNone;

   528 		}

   529 	settings.WriteConfigurationDataL();	

   530 	CleanupStack::PopAndDestroy(temp);

   531 	return ret;

   532 	}

   533 

   534 EXPORT_C TInt CContactSyncChecker::SynchroniseIccPhonebookL(CContactDatabase& aDb, TUid aPhonebookUid, TInt aCompletionError, TInt aSyncError)

   535 	{

   536 	CContactSyncData* temp = CContactSyncData::NewL();

   537 	CleanupStack::PushL(temp);

   538 	CContactSyncData& settings = temp->DataL();

   539 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   540 	TInt ret = KErrNotSupported;

   541 

   542 	if (phbkData)

   543 		{

   544 		ret = phbkData->SynchronisePhonebook(aDb, aCompletionError, aSyncError);

   545 		}

   546 	settings.WriteConfigurationDataL();	

   547 	CleanupStack::PopAndDestroy(temp);

   548 	return ret;

   549 	}

   550 

   551 /**

   552  Synchronise all waiting phonebooks.

   553  Also sets all validate responses to KErrNone.

   554 

   555   @param aDb connection to the databse to sync to.

   556   @param aCompletionError System error to send to all observers

   557   @param aSyncError System error to leave with when Phonebook Sync IsSynchronisedL() API is called.

   558  */

   559 EXPORT_C TInt CContactSyncChecker::SynchroniseIccAllPhonebooksL(CContactDatabase& aDb, TInt aCompletionError, TInt aSyncError)

   560 	{

   561 	CContactSyncData* temp = CContactSyncData::NewL();

   562 	CleanupStack::PushL(temp);

   563 	CContactSyncData& settings = temp->DataL();

   564 	RPointerArray<CContactSyncPhonebookData>& perPhbkData = settings.PerPhonebookData();

   565 	const TInt phbkCount = perPhbkData.Count();

   566 	TInt error(KErrNone);

   567 

   568 	if ((aCompletionError == KErrNone) && (aSyncError == KErrNone))

   569 		{

   570 		SetValidateResponseL(MContactSynchroniser::ERead, KErrNone);

   571 		SetValidateResponseL(MContactSynchroniser::EEdit, KErrNone);

   572 		SetValidateResponseL(MContactSynchroniser::ESearch, KErrNone);

   573 		SetValidateWriteResponseL(KErrNone);

   574 		SetDeleteContactResponseL(KErrNone);

   575 		}

   576 

   577 	// search through phonebook list

   578 	for (TInt k = 0; (k < phbkCount) && (error == KErrNone); ++k)

   579 		{

   580 		// synchronise all waiting phonebooks

   581 		if (perPhbkData[k]->SynchroniseRequired())

   582 			{

   583 			error = perPhbkData[k]->SynchronisePhonebook(aDb, aCompletionError, aSyncError);

   584 			}

   585 		}

   586 	settings.WriteConfigurationDataL();	

   587 	CleanupStack::PopAndDestroy(temp);

   588 

   589 	return error;

   590 	}

   591 

   592 

   593 EXPORT_C TInt CContactSyncChecker::AddContactToPhonebookL(TUid aPhonebookUid, const TDesC& aName, const TDesC& aNumber)

   594 	{

   595 	CContactSyncData* temp = CContactSyncData::NewL();

   596 	CleanupStack::PushL(temp);

   597 	CContactSyncData& settings = temp->DataL();

   598 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   599 	TInt ret = KErrNotSupported;

   600 	if (phbkData)

   601 		{

   602 		TRAP(ret, phbkData->AddPhonebookContactL(aName, aNumber));

   603 		}

   604 	settings.WriteConfigurationDataL();	

   605 	CleanupStack::PopAndDestroy(temp);	

   606 	return ret;

   607 	}

   608 	

   609 EXPORT_C TInt CContactSyncChecker::ResetSyncIccPhonebookL(TUid aPhonebookUid, TBool aResetTemplateAndGroupIds)

   610 	{

   611 	CContactSyncData* temp = CContactSyncData::NewL();

   612 	CleanupStack::PushL(temp);

   613 	CContactSyncData& settings = temp->DataL();

   614 	CContactSyncPhonebookData* phbkData = settings.PhonebookData(aPhonebookUid);

   615 	TInt ret = KErrNotSupported;

   616 

   617 	if (phbkData)

   618 		{

   619 		phbkData->ResetSynchronised(aResetTemplateAndGroupIds);

   620 		ret = KErrNone;

   621 		}

   622 	settings.WriteConfigurationDataL();	

   623 	CleanupStack::PopAndDestroy(temp);	

   624 	return ret;

   625 	}

   626 	

   627 EXPORT_C TInt CContactSyncChecker::ResetSyncIccAllPhonebooksL(TBool aResetTemplateAndGroupIds)

   628 	{

   629 	CContactSyncData* temp = CContactSyncData::NewL();

   630 	CleanupStack::PushL(temp);

   631 	CContactSyncData& settings = temp->DataL();

   632 	RPointerArray<CContactSyncPhonebookData>& perPhbkData = settings.PerPhonebookData();

   633 	const TInt phbkCount = perPhbkData.Count();

   634 

   635 	// search through phonebook list

   636 	for (TInt k = 0; k < phbkCount; ++k)

   637 		{

   638 		// synchronise all waiting phonebooks

   639 		perPhbkData[k]->ResetSynchronised(aResetTemplateAndGroupIds);

   640 		}

   641 	settings.WriteConfigurationDataL();	

   642 	CleanupStack::PopAndDestroy(temp);	

   643 	return KErrNone;

   644 	}

   645 	

   646 // Configure simulation for GSM Phonebook

   647 EXPORT_C TInt CContactSyncChecker::SetGsmPhonebookL()

   648 	{

   649 	CContactSyncData* temp = CContactSyncData::NewL();

   650 	CleanupStack::PushL(temp);

   651 	CContactSyncData& settings = temp->DataL();

   652 	TInt error = KErrNone;

   653 	if (settings.PerPhonebookData().Count() != 0)

   654 		{

   655 		// too late - the phonebook list has already been set

   656 		error = KErrGeneral;

   657 		}

   658 		else

   659 		{

   660 		TRAP(error, settings.AllocPhonebookDataL(KUidIccGlobalAdnPhonebook));		

   661 		}

   662 	settings.WriteConfigurationDataL();	

   663 	// create object for GSM ADN phonebook

   664 	CleanupStack::PopAndDestroy(temp);	

   665 	return error;

   666 	}

   667 	

   668 // Configure simulation for USIM (UMTS/WCDMA) Phonebook

   669 EXPORT_C TInt CContactSyncChecker::SetUsimPhonebookL()

   670 	{

   671 	CContactSyncData* temp = CContactSyncData::NewL();

   672 	CleanupStack::PushL(temp);

   673 	CContactSyncData& settings = temp->DataL();

   674 	TInt error = KErrNone;

   675 

   676 	if (settings.PerPhonebookData().Count() != 0)

   677 		{

   678 		// too late - the phonebook list has already been set

   679 		error = KErrGeneral;

   680 		}

   681 		else

   682 		{

   683 		// create object for USIM App ADN phonebook

   684 		TRAP(error, settings.AllocPhonebookDataL(KUidUsimAppAdnPhonebook));	

   685 		}

   686 	settings.WriteConfigurationDataL();	

   687 	CleanupStack::PopAndDestroy(temp);	

   688 	return error;

   689 	}

   690 	

   691 // Configure custom Phonebook simulation

   692 EXPORT_C TInt CContactSyncChecker::SetPhonebookListL(const RArray<TUid> aNewPhonebookList)

   693 	{

   694 	CContactSyncData* temp = CContactSyncData::NewL();

   695 	CleanupStack::PushL(temp);

   696 	CContactSyncData& settings = temp->DataL();

   697 	TInt error = KErrNone;

   698 	if (settings.PerPhonebookData().Count() != 0)

   699 		{

   700 		// too late - the phonebook list has already been set

   701 		error = KErrGeneral;

   702 		}

   703 		else

   704 		{

   705 		TInt const phbkCount = aNewPhonebookList.Count();

   706 		error = KErrNone;

   707 

   708 		for (TInt k = 0; (k < phbkCount) && !error; ++k)

   709 			{

   710 			// create object for requested phonebook

   711 			TRAP(error, settings.AllocPhonebookDataL(aNewPhonebookList[k]));

   712 			}			

   713 		}

   714 	settings.WriteConfigurationDataL();	

   715 	CleanupStack::PopAndDestroy(temp);		

   716 	return error;

   717 	}

   718 

   719 // Get phonebook list

   720 EXPORT_C TInt CContactSyncChecker::PhonebookListL(RArray<TUid>& aPhonebookList)

   721 	{

   722 	CContactSyncData* temp = CContactSyncData::NewL();

   723 	CleanupStack::PushL(temp);

   724 	CContactSyncData& settings = temp->DataL();

   725 	RPointerArray<CContactSyncPhonebookData>& perPhbkData = settings.PerPhonebookData();

   726 	const TInt phbkCount = perPhbkData.Count();

   727 	TInt ret = KErrNone;

   728 	if (phbkCount == 0)

   729 		{

   730 		// too early - the phonebook list has not been set

   731 		ret = KErrNotReady;

   732 		}

   733 		else

   734 		{

   735 		// copy/create phonebook list

   736 		aPhonebookList.Reset();

   737 		for (TInt k = 0; k < phbkCount; ++k)

   738 			{

   739 			if (aPhonebookList.Append(perPhbkData[k]->PhonebookUid()) != KErrNone)

   740 				{

   741 				// error

   742 				aPhonebookList.Reset();

   743 				ret = KErrNoMemory;

   744 				break;

   745 				}

   746 			}

   747 			

   748 		}

   749 	CleanupStack::PopAndDestroy(temp);		

   750 	return ret;

   751 	}

   752 

   753