1 // Copyright (c) 2007-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 "cntsyncchecker.h"

    17 #include "cntsyncphonedata.h"

    18 #include <cntdef.h>

    19 #include <cntdb.h>

    20 #include "cntsyncdata.h"

    21 

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

    23 #include <e32property.h>

    24 #include <phbksync.h>

    25 

    26 //---------------------------------------------------

    27 CContactSyncPhonebookData* CContactSyncPhonebookData::NewL(TUint32& aCRKey, CRepository* aRepository)

    28 	{

    29 	TUid temp;

    30 	temp.iUid = 0;

    31 	CContactSyncPhonebookData* self = new(ELeave) CContactSyncPhonebookData(temp, aRepository);

    32 	self->InternaliseFromCRL(aCRKey);

    33 	return self;

    34 	}

    35 

    36 

    37 CContactSyncPhonebookData* CContactSyncPhonebookData::NewLC(TUid aPhonebookUid, CRepository* aRepository)

    38 	{

    39 	CContactSyncPhonebookData* self = new(ELeave) CContactSyncPhonebookData(aPhonebookUid, aRepository);

    40 	CleanupStack::PushL(self);

    41 	return self;

    42 	}

    43 

    44 

    45 CContactSyncPhonebookData::CContactSyncPhonebookData(TUid aPhonebookUid, CRepository* aRepository)

    46 	: iPhonebookUid(aPhonebookUid), iPhonebookTemplateId(KNullContactId), iPhonebookGroupId(KNullContactId), iRepository(aRepository)

    47 	{

    48 	}

    49 

    50 const TDesC& CContactSyncPhonebookData::TemplateLabel()

    51 	{

    52 	_LIT(KPhbkTemplateADN,"SIM Card Contacts ADN"); // should be in a resource file for localisation really ;) 

    53 	_LIT(KPhbkTemplateSDN,"SIM Card Contacts SDN");

    54 	_LIT(KPhbkTemplateLND,"SIM Card Contacts LND");

    55 	_LIT(KPhbkTemplateUSimApp,"SIM Card Contacts USIMAPP");

    56 	_LIT(KPhbkTemplateFDN,"SIM Card Contacts FDN");

    57 	_LIT(KPhbkTemplateNotSpecified,"SIM Card Contacts Name Not Specified");

    58 

    59 

    60 	/* Some Contacts test code used to set group names

    61 	_LIT(KGlobalAdnGroupName,"Global Adn Group");

    62 	_LIT(KGlobalSdnGroupName,"Global Sdn Group");

    63 	_LIT(KGlobalLdnGroupName,"Global Lnd Group");

    64 	_LIT(KUsimAppAdnGroupName,"Usim App Adn Group");

    65 	*/

    66 

    67 	switch (iPhonebookUid.iUid)

    68 		{

    69 		case KUidIccGlobalAdnPhonebookValue:

    70 			return KPhbkTemplateADN;

    71 

    72 		case KUidIccGlobalSdnPhonebookValue:

    73 			return KPhbkTemplateSDN;

    74 

    75 		case KUidIccGlobalLndPhonebookValue:

    76 			return KPhbkTemplateLND;

    77 

    78 		case KUidUsimAppAdnPhonebookValue:

    79 			return KPhbkTemplateUSimApp;

    80 

    81 		case KUidIccGlobalFdnPhonebookValue:

    82 			return KPhbkTemplateFDN;

    83 

    84 		default:

    85 			break;

    86 		}

    87 

    88 	return KPhbkTemplateNotSpecified;

    89 	}

    90 

    91 

    92 CContactSyncPhonebookData::~CContactSyncPhonebookData()

    93 	{

    94 	delete iIccTemplate;

    95 	iStatusArray.Close();

    96 	iPhonebookContacts.ResetAndDestroy();

    97 	}

    98 

    99 

   100 void CContactSyncPhonebookData::AddPhonebookContactL(const TDesC& aName, const TDesC& aNumber)

   101 	{

   102 	iPhonebookContacts.AppendL(CPhonebookContact::NewLC(aName, aNumber, iRepository));

   103 	CleanupStack::Pop();	// CPhonebookContact

   104 	}

   105 

   106 

   107 TInt CContactSyncPhonebookData::SynchronisePhonebook(CContactDatabase& aDb, TInt aCompletionError, TInt aLeaveError)

   108 	{

   109 	TInt error(KErrNone);

   110 

   111 	__ASSERT_DEBUG(iIsSynchronised == EFalse, User::Invariant());

   112 

   113 

   114 	if ((aCompletionError == KErrNone) && (aLeaveError == KErrNone))

   115 		{

   116 		// Validate any template ID remembered from previous test

   117 		if ((iPhonebookTemplateId != KNullContactId) &&    // if value has not been set

   118 			(iPhonebookTemplateId != KGoldenTemplateId) )  // internally initialised value by cntmodel

   119 			{

   120 			TRAP(error, ValidateTemplateIdAndLabelL(aDb));

   121 

   122 			if (error)

   123 				{

   124 				if (error != KErrNotFound)

   125 					{

   126 					return error;

   127 					}

   128 				iPhonebookTemplateId = KNullContactId;

   129 				}

   130 			}

   131 

   132 		// Need to create a new template?

   133 		if ((iPhonebookTemplateId == KNullContactId) ||  // if value has not been set

   134 			(iPhonebookTemplateId == KGoldenTemplateId)) // internally initialised value by cntmodel

   135 			{

   136 			if (iIccTemplate)

   137 				{

   138 				delete iIccTemplate;

   139 				iIccTemplate = NULL;

   140 				}

   141 

   142 			TRAP(error, CreateTemplateIdL(aDb)); // First create Template ID

   143 

   144 			if (error == KErrNone)

   145 				{

   146 				// cache template

   147  				TRAP(error, iIccTemplate = aDb.ReadContactL(iPhonebookTemplateId));

   148 				}

   149 

   150 			if (error)

   151 				{

   152 				return error;

   153 				}

   154 			}

   155 

   156 

   157 

   158 		// Validate any group ID remembered from previouzs test

   159 		if ((iPhonebookGroupId != KNullContactId) &&    // if value has not been set

   160 			(iPhonebookGroupId != KGoldenTemplateId) )  // internally initialised value by cntmodel

   161 			{

   162 			TRAP(error, ValidateGroupIdAndTemplateL(aDb));

   163 

   164 			if (error)

   165 				{

   166 				if (error != KErrNotFound)

   167 					{

   168 					return error;

   169 					}

   170 				iPhonebookGroupId = KNullContactId;

   171 				}

   172 			}

   173 

   174 		if ((iPhonebookGroupId == KNullContactId) ||    // if value has not been set

   175 			(iPhonebookGroupId == KGoldenTemplateId) )  // internally initialised value by cntmodel

   176 			{

   177 			// Now create group ID for this phonebook

   178 			TRAP(error, CreateGroupIdL(aDb));

   179 			}

   180 

   181 		if (error == KErrNone && iPhonebookContacts.Count() > 0)

   182 			{

   183 			TRAP(error, SynchroniseContactsL(aDb));

   184 			}

   185 

   186 		if (error)

   187 			{

   188 			return error;

   189 			}

   190 

   191 		// successfully synchronised

   192 		iIsSynchronised = ETrue;

   193 		}

   194 

   195 

   196 	CompleteNotificationRequest(aCompletionError);

   197 	iSynchronisedLeaveCode = aLeaveError;

   198 	

   199 	// simulated synchronisation completed

   200 	return KErrNone;

   201 	}

   202 

   203 

   204 void CContactSyncPhonebookData::ValidateTemplateIdAndLabelL(CContactDatabase& aDb)

   205 	{

   206 	CContactItem* item = aDb.ReadContactLC(iPhonebookTemplateId);

   207 

   208 	// The following test confirms if a template ID relates to this phonebook's 

   209 	// template by checking the label employed.

   210 	if ((item->Type() != KUidContactCardTemplate) ||

   211 			(static_cast<CContactCardTemplate*>(item)->GetTemplateLabelL() != TemplateLabel()))

   212 		{

   213 		iPhonebookTemplateId = KNullContactId;

   214 		}

   215 

   216 	CleanupStack::PopAndDestroy(item);

   217 	}

   218 

   219 

   220 void CContactSyncPhonebookData::ValidateGroupIdAndTemplateL(CContactDatabase& aDb)

   221 	{

   222 	CContactGroup* group = static_cast<CContactGroup*> (aDb.ReadContactL(iPhonebookGroupId));

   223 

   224 	CleanupStack::PushL(group);

   225 

   226 	// check that contact id refers to a group

   227 	if (group->Type() == KUidContactGroup)

   228 		{

   229 		// Retrieve the first entry in the group, and check that entry's template ID

   230 		CContactIdArray* itemList = group->ItemsContainedLC();

   231 		if (itemList->Count() > 0)

   232 			{

   233 			CContactItem* groupItem = aDb.ReadContactLC((*itemList)[0]);

   234 			if (groupItem)

   235 				{

   236 				if (groupItem->TemplateRefId() != iPhonebookTemplateId)

   237 					{

   238 					// wrong group

   239 					iPhonebookGroupId = KNullContactId;

   240 					}

   241 				CleanupStack::PopAndDestroy(groupItem);

   242 				}

   243 			}

   244 		CleanupStack::PopAndDestroy(itemList);

   245 		}

   246 	else

   247 		{

   248 		// id is not really a group

   249 		iPhonebookGroupId = KNullContactId;

   250 		}

   251 

   252 	CleanupStack::PopAndDestroy(group);

   253 	}

   254 

   255 

   256 /**

   257  Create Template UID for the phonebook.

   258 

   259  (Beware - can leave partially created Template)

   260 

   261  @param aDb Handle to the contacts database.

   262  */

   263 void CContactSyncPhonebookData::CreateTemplateIdL(CContactDatabase &aDb)

   264 	{

   265 	__ASSERT_DEBUG((iPhonebookTemplateId == KNullContactId || iPhonebookTemplateId == KGoldenTemplateId), User::Invariant());

   266 

   267 	// First check if there is an existing template in the contact database for this phonebook

   268 	CContactIdArray* idList = aDb.GetCardTemplateIdListL();

   269 	if (idList)

   270 		{

   271 		CleanupStack::PushL(idList);

   272 		const TInt idListCount = idList->Count();

   273 		if (idListCount > 0)

   274 			{

   275 			TInt i;

   276 			for (i = 0; i < idListCount; i++)

   277 				{

   278 				CContactCardTemplate* item = static_cast<CContactCardTemplate*> (aDb.ReadContactLC((*idList)[i]));

   279 				if (item->GetTemplateLabelL() == TemplateLabel())

   280 					{

   281 					iPhonebookTemplateId = (*idList)[i];

   282 					i = idListCount; // force loop to exit

   283 					}

   284 				CleanupStack::PopAndDestroy(item);

   285 				}

   286 			}

   287 		CleanupStack::PopAndDestroy(idList);

   288 		}

   289 

   290 	// If no suitable template been found create a new one

   291 	if (iPhonebookTemplateId == KNullContactId ||

   292 			iPhonebookTemplateId == KGoldenTemplateId)

   293 		{

   294 		// "Creating template for this phonebook"

   295 

   296 		CContactItem* newTemplate = aDb.CreateContactCardTemplateLC(TemplateLabel());

   297 

   298 		TContactItemId templateId = newTemplate->Id();

   299 		CleanupStack::PopAndDestroy(newTemplate);

   300 

   301 		// Remove all the unnecessary fields

   302 		newTemplate = aDb.OpenContactLX(templateId);

   303 		CleanupStack::PushL(newTemplate);	

   304 		const TInt fieldCount = newTemplate->CardFields().Count();

   305 		for(TInt i=fieldCount-1;i>=0;i--)

   306 			newTemplate->RemoveField(i);

   307 			

   308 		// Add default name field

   309 		CContactItemField* name = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);

   310 

   311 		name->SetLabelL(_L("Name"));

   312 		name->SetMapping(KUidContactFieldVCardMapUnusedN);

   313 		newTemplate->AddFieldL(*name);

   314 		CleanupStack::Pop(name);

   315 			

   316 		// Add second name field

   317 		CContactItemField* secondName = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldSecondName);

   318 		secondName->SetLabelL(_L("Additional Name"));

   319 		secondName->SetMapping(KUidContactFieldVCardMapSECONDNAME);

   320 		secondName->SetUserFlags(EContactCategoryHome);

   321 		newTemplate->AddFieldL(*secondName);

   322 		CleanupStack::Pop(secondName);

   323 			

   324 		// Add default number field

   325 		CContactItemField* number = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldPhoneNumber);

   326 		number->SetLabelL(_L("Phone Number"));

   327 		number->SetMapping(KUidContactFieldVCardMapTEL);

   328 		number->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   329 		number->AddFieldTypeL(KUidContactFieldVCardMapVOICE);

   330 		number->AddFieldTypeL(KUidContactFieldVCardMapCELL);

   331 		newTemplate->AddFieldL(*number);

   332 		CleanupStack::Pop(number);

   333 

   334 		// Add Slot Number field

   335 		CContactItemField* slotnum = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldICCSlot);

   336 		slotnum->SetLabelL(_L("Slot"));

   337 		slotnum->SetMapping(KUidContactFieldVCardMapNotRequired);

   338 		newTemplate->AddFieldL(*slotnum);

   339 		CleanupStack::Pop(slotnum);

   340 

   341 		// Add Phonebook type field

   342 		CContactItemField* phonebook = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldICCPhonebook);

   343 		phonebook->SetLabelL(_L("Phonebook UID"));

   344 		phonebook->SetMapping(KUidContactFieldVCardMapNotRequired);

   345 		newTemplate->AddFieldL(*phonebook);

   346 		CleanupStack::Pop(phonebook);

   347 

   348 		// presume this is a 3G ICC so there are additional fields for ADN and USIM App phonebooks 

   349 		if((iPhonebookUid.iUid == KUidIccGlobalAdnPhonebookValue) || 

   350 		   (iPhonebookUid.iUid == KUidUsimAppAdnPhonebookValue))

   351 			{

   352 			// Add e-mail field

   353 			CContactItemField* emailField = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldEMail);

   354 			emailField->SetLabelL(_L("Email"));

   355 			emailField->SetMapping(KUidContactFieldVCardMapEMAILINTERNET);

   356 			emailField->AddFieldTypeL(KUidContactFieldVCardMapWORK);

   357 			emailField->SetUserFlags(EContactCategoryOther);

   358 			newTemplate->AddFieldL(*emailField);

   359 			CleanupStack::Pop(emailField);

   360 

   361 			// Add group field - this is different from contacts group. This field indicates 

   362 			// group that this ICC entry belongs to. User can add this entry to a number of 

   363 			// groups on ICC i.e. business, private, etc. 

   364 			CContactItemField* group = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldICCGroup);

   365 			group->SetLabelL(_L("Group"));

   366 			group->SetMapping(KUidContactFieldVCardMapUnusedN);

   367 			newTemplate->AddFieldL(*group);

   368 			CleanupStack::Pop(group);

   369 			}

   370 

   371  		// Now that we know nothing as left, assign member variables (this avoids member variables being left in a bad state in the event of a leave).

   372  		iPhonebookTemplateId = templateId;

   373 

   374 		aDb.CommitContactL(*newTemplate);

   375 		CleanupStack::PopAndDestroy(2);	// newTemplate plus locked record

   376 		}

   377 	}

   378 

   379 

   380 /**

   381  Create Group UID for the phonebook.

   382  @param aDb Handle to the contacts database.

   383  */

   384 void CContactSyncPhonebookData::CreateGroupIdL(CContactDatabase &aDb)

   385 	{

   386 	__ASSERT_DEBUG((iPhonebookGroupId == KNullContactId ||

   387 		iPhonebookGroupId == KGoldenTemplateId), User::Invariant());

   388 

   389 	// First check if there is an existing group in the contact database for this phonebook

   390 	CContactIdArray* idList = aDb.GetGroupIdListL();

   391 	if (idList)

   392 		{

   393 		CleanupStack::PushL(idList);

   394 

   395 		const TInt idListCount = idList->Count();

   396 		if (idListCount > 0)

   397 			{

   398 			TInt i;

   399 			for (i = 0; i < idListCount; i++)

   400 				{

   401 				// Retrieve the first entry in each group, and check that entry's template ID

   402 				CContactGroup* group = static_cast<CContactGroup*> (aDb.ReadContactLC((*idList)[i]));

   403 				CContactIdArray* itemList = group->ItemsContainedLC();

   404 				if (itemList->Count() > 0)

   405 					{

   406 					CContactItem* groupItem = aDb.ReadContactLC((*itemList)[0]);

   407 					if (groupItem->TemplateRefId() == iPhonebookTemplateId)

   408 						{

   409 						iPhonebookGroupId = (*idList)[i];

   410 						i = idListCount; // force exit from loop

   411 						}

   412 					CleanupStack::PopAndDestroy(groupItem);

   413 					}

   414 				CleanupStack::PopAndDestroy(2, group); // itemList, group

   415 				}

   416 			}

   417 

   418 		CleanupStack::PopAndDestroy(idList);

   419 		}

   420 

   421 	// If no suitable group has been found create a new one

   422 	if (iPhonebookGroupId==KNullContactId ||

   423 			iPhonebookGroupId==KGoldenTemplateId)

   424 		{

   425 		CContactItem* group = aDb.CreateContactGroupLC(KNullDesC);

   426  		iPhonebookGroupId = group->Id();

   427 		CleanupStack::PopAndDestroy(group);

   428 		}

   429 	}

   430 

   431 

   432 void CContactSyncPhonebookData::SynchroniseContactsL(CContactDatabase &aDb)

   433 	{

   434 	const TInt nContacts = iPhonebookContacts.Count();

   435 

   436 	// simple version of phonebook sync

   437 	for (TInt idx = 0; idx < nContacts; ++idx)

   438 		{

   439 		CContactICCEntry* item = CContactICCEntry::NewL(*iIccTemplate);

   440 		CleanupStack::PushL(item); 

   441 

   442 		CContactItemFieldSet& fieldSet = item->CardFields();

   443 

   444 		// add name text

   445 		TInt pos = fieldSet.Find(KUidContactFieldFamilyName);

   446 		if (pos != KErrNotFound)

   447 			{

   448 			fieldSet[pos].TextStorage()->SetTextL(*iPhonebookContacts[idx]->Name());

   449 			}

   450 

   451 		// add phone number

   452 		pos = fieldSet.Find(KUidContactFieldPhoneNumber);

   453 		if (pos != KErrNotFound)

   454 			{

   455 			fieldSet[pos].TextStorage()->SetTextL(*iPhonebookContacts[idx]->Number());

   456 			}

   457 

   458 		// ICC Phonebook slot

   459 		pos = fieldSet.Find(KUidContactFieldICCSlot);

   460 		if (pos != KErrNotFound)

   461 			{

   462 			TBuf16<20> numberBuffer;

   463 			numberBuffer.Format(_L("%d"), idx + 1);

   464 			fieldSet[pos].TextStorage()->SetTextL(numberBuffer);

   465 			}

   466 

   467 		TContactItemId id = aDb.AddNewContactL(*item);

   468 

   469 

   470 

   471 		CleanupStack::PopAndDestroy(item);

   472 		

   473 		// debug print fields

   474 		CContactItem* contact = aDb.ReadContactLC(id);

   475 		

   476 		CContactItemFieldSet& contactFields = contact->CardFields();

   477 		const TInt fieldCount = contactFields.Count();

   478 

   479 		for (TInt i=0; i < fieldCount; i++)

   480 			{

   481 			CContactItemField &field = contactFields[i];

   482 			if (field.StorageType() == KStorageTypeText)

   483 				{

   484 				TPtrC fieldText = field.TextStorage()->Text();

   485 				TPtrC labelText = field.Label();

   486 			    RDebug::Print(_L("--Field(%d) %S: %S \n\r"), i, &labelText, &fieldText);

   487 				}

   488 			}

   489 		CleanupStack::PopAndDestroy(contact);	

   490 

   491 		}

   492 

   493 	if (nContacts)

   494 		{

   495 		aDb.CompactL();

   496 		}

   497 	}

   498 

   499 

   500 void CContactSyncPhonebookData::ResetSynchronised(TBool aResetTemplateAndGroupIds)

   501 	{

   502 	if (aResetTemplateAndGroupIds)

   503 		{

   504 		iPhonebookTemplateId = KNullContactId;

   505 		iPhonebookGroupId = KNullContactId;

   506 		}

   507 

   508 	// tell observers that synchronisation state has changed

   509 	CompleteNotificationRequest(KErrNone);

   510 

   511 	// not synchronised

   512 	iIsSynchronised = EFalse;

   513 	iSynchronisedLeaveCode = KErrNone;

   514 	}

   515 

   516 

   517 TInt CContactSyncPhonebookData::StoreNotificationRequest(TInt aStatus)

   518 	{

   519 //	aStatus = KRequestPending;

   520 	iNotificationPending++;

   521 	return iStatusArray.Append(aStatus);

   522 	}

   523 

   524 

   525 void CContactSyncPhonebookData::CompleteNotificationRequest(TInt aError)

   526 	{	

   527 	const TInt count = iStatusArray.Count();

   528 	

   529 	for (TInt k = count; k > 0; --k)

   530 		{

   531 		iNotificationPending--; 

   532 		RProperty::Set(

   533 			SyncNotification::KPropertyCategory, 

   534 			iPhonebookUid.iUid, 

   535 			aError);

   536 		}

   537 	iErrorCode = aError;

   538 	iStatusArray.Reset();	

   539 	}

   540 	

   541 void CContactSyncPhonebookData::CancelNotificationRequestL()

   542 	{	

   543 	const TInt count = iStatusArray.Count();

   544 	RProperty property;

   545 	

   546 	for (TInt k = count; k > 0; --k)

   547 		{

   548 		iNotificationPending--; 

   549 		User::LeaveIfError(property.Attach(SyncNotification::KPropertyCategory,iPhonebookUid.iUid));

   550 		property.Cancel();

   551 		}

   552 	iStatusArray.Reset();	

   553 	}

   554 

   555 

   556 TInt CContactSyncPhonebookData::NotificationPendingCount()

   557 	{

   558 	return iStatusArray.Count();

   559 	}

   560 

   561 

   562 void CContactSyncPhonebookData::SetTemplateId(TInt aPhonebookTemplateId)

   563 	{

   564 	iPhonebookTemplateId = aPhonebookTemplateId;

   565 	}

   566 

   567 

   568 void CContactSyncPhonebookData::SetGroupId(TInt aPhonebookGroupId)

   569 	{

   570 	iPhonebookGroupId = aPhonebookGroupId;

   571 	}

   572 

   573 

   574 const TUid& CContactSyncPhonebookData::PhonebookUid()

   575 	{

   576 	return iPhonebookUid;

   577 	}

   578 

   579 

   580 TInt CContactSyncPhonebookData::TemplateId()

   581 	{

   582 	return iPhonebookTemplateId;

   583 	}

   584 

   585 

   586 TInt CContactSyncPhonebookData::GroupId()

   587 	{

   588 	return iPhonebookGroupId;

   589 	}

   590 

   591 

   592 void CContactSyncPhonebookData::SetSynchronisedLeaveCode(TInt aLeaveError)

   593 	{

   594 	iSynchronisedLeaveCode = aLeaveError;

   595 	}

   596 

   597 

   598 void CContactSyncPhonebookData::SetSynchronised(TInt aSynchronised)

   599 	{

   600 	iIsSynchronised = aSynchronised;

   601 	}

   602 

   603 

   604 TBool CContactSyncPhonebookData::IsSynchronisedL()

   605 	{

   606 	User::LeaveIfError(iSynchronisedLeaveCode);

   607 	return iIsSynchronised;

   608 	}

   609 

   610 

   611 TBool CContactSyncPhonebookData::SynchroniseRequired()

   612 	{

   613 	return !iIsSynchronised;

   614 	}

   615 	

   616 void CContactSyncPhonebookData::InternaliseFromCRL(TUint32& aCRKey)

   617 	{

   618 	TInt temp;

   619 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, temp, *iRepository);

   620     iPhonebookUid.iUid = temp;

   621 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, temp, *iRepository);

   622     iPhonebookTemplateId = temp;

   623 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, temp, *iRepository);

   624     iPhonebookGroupId = temp;

   625 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, iIsSynchronised, *iRepository);

   626 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, iNotificationPending, *iRepository);

   627 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, iErrorCode, *iRepository);

   628 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, iSynchronisedLeaveCode, *iRepository); 

   629 	TInt notificationVectorSize = 0;

   630 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, notificationVectorSize, *iRepository);

   631     for (TInt i = 0 ; i < notificationVectorSize ; i++)

   632 	    {    

   633 		TInt notification;

   634 		CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, notification, *iRepository);

   635 	    iStatusArray.Append(notification);	

   636 	    }

   637 	TInt numberOfPhonebookContacts = 0;

   638 	CContactSyncStaticRepository::ReadIntFromCentralRepositoryL(aCRKey, numberOfPhonebookContacts, *iRepository);

   639 	aCRKey+=10 - iStatusArray.Count();

   640     for (TInt i2 = 0 ; i2 < numberOfPhonebookContacts ; i2++)

   641 	    {    

   642 		CPhonebookContact* temp;

   643 		temp = CPhonebookContact::NewL(aCRKey, iRepository);

   644 		iPhonebookContacts.Append(temp);

   645 	    }

   646 	aCRKey+=10;

   647 	}

   648 	

   649 void CContactSyncPhonebookData::ExternaliseToCRL(TUint32& aCRKey)

   650 	{

   651 	TInt temp = iPhonebookUid.iUid;

   652     //TRAP(Err, iRepository->Set(aCRKey++, temp));

   653 	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, temp, *iRepository);

   654 

   655     temp = iPhonebookTemplateId;

   656 	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, temp, *iRepository);

   657     temp = iPhonebookGroupId;

   658 	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, temp, *iRepository);

   659 	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, iIsSynchronised, *iRepository);

   660  	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, iNotificationPending, *iRepository);

   661  	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, iErrorCode, *iRepository);

   662 	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, iSynchronisedLeaveCode, *iRepository); 

   663  	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, iStatusArray.Count(), *iRepository);

   664 	for (TInt i = 0 ; i < iStatusArray.Count() ; i++)

   665 	    {    

   666 		TInt notification(iStatusArray[i]);

   667  		CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, notification, *iRepository);

   668 	    }	

   669  	CContactSyncStaticRepository::WriteIntToCentralRepositoryL(aCRKey, iPhonebookContacts.Count(), *iRepository);

   670 	aCRKey+=10 - iStatusArray.Count();

   671     for (TInt i2 = 0 ; i2 < iPhonebookContacts.Count() ; i2++)

   672 	    { 

   673 	    CPhonebookContact* temp = iPhonebookContacts[i2];

   674 	    temp->WriteToCRL(aCRKey);   

   675 	    }

   676 	aCRKey+=10;

   677 	}

   678 

   679 TInt CContactSyncPhonebookData::ErrorCode()

   680 	{

   681 	return iErrorCode;

   682 	}

   683 

   684