TBool CPackagerCntComparator::DoCompareCContactItemFieldSet(const CContactItemFieldSet& anItemFieldSet1, const CContactItemFieldSet& anItemFieldSet2) const
/** Compares two CContactItemFieldSet items.
@param anItemFieldSet1 The first CContactItemFieldSet to be compared.
@param anItemFieldSet2 The second CContactItemFieldSet to be compared.
@return ETrue if the two items are equal, EFalse otherwise. */
{// Need to check for NULL arrays first.
if((!&anItemFieldSet1[0]) && (!&anItemFieldSet2[0]))
{
return ETrue;
}
if((!&anItemFieldSet1[0]) || (!&anItemFieldSet2[0]))
{
return EFalse;
}
// Check if arrays are same length to begin with.
TInt maxCount = anItemFieldSet1.Count();
if(!DoCompareTInt(maxCount, anItemFieldSet2.Count()))
{
return EFalse;
}
for(TInt i=0; i<maxCount; ++i)
{
if(!(DoCompareCContactItemField(anItemFieldSet1[i],anItemFieldSet2[i])))
{
return EFalse;
}
}
return ETrue;
}
/**
Utility method used to read text blob fields from contacts database. Provides a mechanism to
fill a contact item with informations stored in text blobs within contact database.
A reference to the contact item to be fill has to be provided. A template has to be provided
if the contact item is based on a template. Template can be NULL. Also a view definition can
be provided to filter which fields are read from blob fields.
@param aTextHeader reference to a read stream from which header values will be read
@param aTextValues reference to a descriptor from which text values will be read
@param aItem Contact item to be filled with information from text blob field.
@param aView View definition specifying what item fields should be read from text blob field
@param aTemplate Contact item representing a template based on which aItem should be read. Can be NULL
@leave KErrNotFound if the specified contact item does not exist any more in contact database
*/
void TCntPersistenceUtility::ReadTextBlobL(CEmbeddedStore& aTextHeaderStore, TPtrC& aTextValues, CContactItem& aItem, const CContactItemViewDef& aView, const CContactItem* aTemplate)
{
HBufC* textFieldsBuf = aTextValues.AllocLC();
if (aTemplate)
{
// If a system template is provided, we create a new CContactItemFieldSet object
// and restore it based on provided template (CContactItemField objects composing
// template). CContactItem object will be set with the newly created CContactItemFieldSet.
CContactItemFieldSet* original = CContactItemFieldSet::NewLC();
RestoreTextL(*original, aTextHeaderStore, aTextHeaderStore.Root(), textFieldsBuf, aView, aTemplate);
for(TInt loop = 0;loop < original->Count();loop++)
{
CContactItemField* additionalField = CContactItemField::NewLC((*original)[loop]);
aItem.CardFields().AddL(*additionalField);
CleanupStack::Pop(additionalField);
}
CleanupStack::PopAndDestroy(original);
}
else
{
// If there is no template provided, we will fill the CContactItemField set provided
// in the curent CContactItem object
RestoreTextL(aItem.CardFields(), aTextHeaderStore, aTextHeaderStore.Root(), textFieldsBuf, aView, NULL);
}
CleanupStack::PopAndDestroy(textFieldsBuf);
}
void CReadContactsAO::GetTextFieldFromFieldSet(CContactItemFieldSet& aFieldSet, const TUid aField,TDesC& name)
{
TInt index = aFieldSet.Find(aField);
if ((index >= 0) && (index < aFieldSet.Count()))
{
CContactItemField& textfield = aFieldSet[index];
CContactTextField* textValue = textfield.TextStorage();
((TDes&)name).Copy(textValue->Text());
}
}
/**
this function encompasses two tests
Test1(!aNewFields) opens contact item, and adds a custom uid to each field, changes lable to custom label
then checks if uid and label were stored correctly
Test2(aNewFields) opens contact item and adds ten new fields, and adds a custom uid to
each field(new and old), changes lable to custom label then checks if uid and
label were stored correctly. also checks both uids of new fields
*/
void CCustomLabelUid::TestCustomUidLabelsL( const TContactItemId aCid, const TBool aNewFields )
{
CContactItem *contactItem = NULL;
//open contact
contactItem = iContactsDatabase->OpenContactLX(aCid,*iViewAll);
CleanupStack::PushL(contactItem);
CContactItemFieldSet *ContactFields = &(contactItem->CardFields());
if(aNewFields)
{
TInt length = 10;//add 10 new custom fields
for(TInt i = 0, uids = TestConstants::KAltUID; i < length; i++, uids++)
{
AddNewFieldL( *ContactFields, TestConstants::KShortString, TFieldType::Uid(uids) );
}
}
//set custom labels for contact fields
SetContactLabelsL(*contactItem);
//set custom uids for contact fields
AddUIDsL(*ContactFields,TestConstants::KInitialUID);
//populate contact fields and update
SetContactFieldsL(*contactItem);
iContactsDatabase->CommitContactL(*contactItem);
CleanupStack::PopAndDestroy(contactItem);
CleanupStack::Pop();//lock
//read contact
contactItem = NULL;
contactItem = iContactsDatabase->ReadContactLC(aCid,*iViewAll);
ContactFields = &(contactItem->CardFields());
//check uids were update correctly
SINGLECOMPARE( CheckUIDsL(*ContactFields,TestConstants::KInitialUID),0,0 );
//check labels were update correctly
SINGLECOMPARE( CheckContactLabelsL(*contactItem),0,0 );
//check fields were populated correctly
SINGLECOMPARE( CheckContactFieldsL(*contactItem),0,0 );
if(aNewFields)
{
//check that new fields contain the correct uids(2), initial and updated custom values
TInt length = ContactFields->Count();
TInt i = ContactFields->Find( TFieldType::Uid(TestConstants::KAltUID) );
for(TInt uids = TestConstants::KAltUID; i < length; i++, uids++)
{
SINGLECOMPARE( CheckNewFieldL( *ContactFields, i, TFieldType::Uid(uids) ), i, 0);
}
}
CleanupStack::PopAndDestroy(contactItem);
}
/**Utility function to remove any specified contact field from a specified contact item*/
TBool CAgentTest::RemoveFieldFromContactL(TContactItemId aContactId, TUid aContactField)
{
CContactItem* mainItem = NULL;
CContactItemFieldSet* fields = NULL;
mainItem = iDb->OpenContactL(aContactId);
CleanupStack::PushL(mainItem);
fields = &mainItem->CardFields();
TInt pos = 0;
pos = fields->Find(aContactField);
if (pos != KErrNotFound)
{
fields->Remove(pos);
}
iDb->CommitContactL(*mainItem);
CleanupStack::PopAndDestroy();
return pos;
}
/**
* Check that the field of type aFieldType has the same content as
* aExpectedContent
* @param aFieldset Contact item fieldset
* @param aFieldType Field type to test
* @param aExpectedContent Expected data
*/
void CheckFieldContentL(CContactItemFieldSet& aFieldset, TFieldType aFieldType, const TDesC& aExpectedContent)
{
TInt pos = aFieldset.Find(aFieldType);
CContactItemField& field = aFieldset[pos];
CContactTextField* textField = field.TextStorage();
test(textField != NULL);
test(textField->Text() == aExpectedContent);
}
/**
Utility method used to read text fields from blob and fill item field set,Provides a mechanism to restore a
contact item field set from text blob field within contact database.
Blob informations are stored based on contact item field. At restore, a reference to a contact item field set
is provided. For every contact item field in the item field set, a text restore is made.
@param aFieldSet Reference to CContactItemFieldSet. Item field set that has to be filled with informations from blob
@param aHeaderStore Stream store containing the header informations
@param aId Root id for the header stream store
@param aValuesStore Read stream used to read text fields from text blob
@param aViewDef View definition indicating which fields have to be read from blob
@param aTemplate Template indicating if current field set should be filled based on a template
*/
void TCntPersistenceUtility::RestoreTextL(CContactItemFieldSet& aFieldSet, CStreamStore& aHeaderStore, TStreamId aId, HBufC* textStream, const CContactItemViewDef& aViewDef, const CContactItem* aTemplate)
{
const TBool KIncludeFields = ( aViewDef.Use() == CContactItemViewDef::EIncludeFields );
if (KIncludeFields && aViewDef.Count() == 0)
{
// If view definition does not contain any field we don't do anything (don't read from
// blob). We simply return from method without doing anything.
// This is not an error condition
return;
}
RStoreReadStream stream;
stream.OpenLC(aHeaderStore,aId);
TCardinality fieldCount;
stream>>fieldCount;
TInt textFieldIndex=0;
for (TInt ii = 0; ii < fieldCount; ++ii)
{
// Restore text for every CContactItemField in provided CContactItemFieldSet.
CContactItemField* field = CContactItemField::NewLC();
if(aTemplate)
{
field->RestoreFieldTypesL(stream, &(aTemplate->CardFields()));
}
else
{
field->RestoreFieldTypesL(stream, NULL);
}
ASSERT(field->StorageType() == KStorageTypeText);
TBool fieldDefined = ETrue;
if(!aViewDef.MatchesAll())
{
fieldDefined = (aViewDef.Find(field->ContentType()) != KErrNotFound);
}
if ((!((fieldDefined && KIncludeFields) || (!fieldDefined && !KIncludeFields))) ||
(field->IsHidden() && aViewDef.Mode() == CContactItemViewDef::EMaskHiddenFields))
{
CleanupStack::PopAndDestroy(field);
}
else
{
field->RestoreTextL(textStream, textFieldIndex);
aFieldSet.AddL(*field);
CleanupStack::Pop(field);
}
++textFieldIndex;
}
CleanupStack::PopAndDestroy(&stream);
}
/**Utility function for finding number of agents in a contact item*/
TInt CAgentTest::GetAgentCountL(TContactItemId aContactId)
{
CContactItem* mainItem = NULL;
mainItem = iDb->ReadContactL(aContactId);
CleanupStack::PushL(mainItem);
CContactItemFieldSet* fields = &mainItem->CardFields();
TInt count = fields->Count();
TInt agentCount = 0;
TInt i = 0;
for(; i < count; ++i)
{
if( (*fields)[i].StorageType() == KStorageTypeContactItemId )
{
++agentCount;
}
}
CleanupStack::PopAndDestroy();
return agentCount;
}
/**
Utility method used to write text and binary blob fields into write streams. The write
streams will be used to persist the blob informations in contact database.
Provides a mechanism to get information from a contact item and store them in the
right blob fields within contact database. Template can be NULL.
@param aTextHeader reference to a write stream in which text header will be written
@param aTextValues reference to a write stream in which text values will be written.
From the caller point of view this reference should be a reference to a RSqlParamWriteStream instance
@param aBinaryHeader reference to a write stream in which binary header will be written
@param aBinaryValues reference to a write stream in which binary values will be written.
@param aItem Contact item to be filled with information from text blob field.
@param aSysTemplate System template item.
*/
void TCntPersistenceUtility::WriteBlobL(CEmbeddedStore& aTextEmbeddedStore, RWriteStream& aTextValues, CEmbeddedStore& aBinaryEmbeddedStore, CEmbeddedStore& aBinaryEmbeddedBlobStore, const CContactItem& aItem, const CContactTemplate* aSysTemplate)
{
CContactItemFieldSet& fieldSet = aItem.CardFields();
CContactItemFieldSet* textFieldSet = CContactItemFieldSet::NewLC();
CContactItemFieldSet* binaryFieldSet = CContactItemFieldSet::NewLC();
for(TInt i = 0; i < fieldSet.Count(); ++i)
{
CContactItemField* item = CContactItemField::NewL((aItem.CardFields())[i]);
CleanupStack::PushL(item);
if(item->StorageType() == KStorageTypeText)
{
textFieldSet->AddL(*item);
}
else
{
binaryFieldSet->AddL(*item);
}
CleanupStack::Pop(item);
}
TStreamId rootId = textFieldSet->StoreL(aTextEmbeddedStore, aSysTemplate, aTextValues, aBinaryEmbeddedBlobStore, NULL);// *textEmbeddedBlobStore);
aTextEmbeddedStore.SetRootL(rootId);
aTextEmbeddedStore.CommitL();
rootId = binaryFieldSet->StoreL(aBinaryEmbeddedStore, aSysTemplate, aTextValues, aBinaryEmbeddedBlobStore, NULL);
aBinaryEmbeddedStore.SetRootL(rootId);
aBinaryEmbeddedStore.CommitL();
aBinaryEmbeddedBlobStore.CommitL();
CleanupStack::PopAndDestroy(2, textFieldSet); //binaryFieldSet, textFieldSet
}
TBool CAgentAddressbook::ContainsEmptyField(const CContactItemFieldSet& fields)
{
for (TInt i = 0; i < fields.Count(); i++)
{
const CContactItemField& itemField = fields[i];
if (itemField.StorageType() == KStorageTypeText || itemField.StorageType() == KStorageTypeDateTime)
{
if (!itemField.Storage()->IsFull())
return ETrue;
}
}
return EFalse;
}
/**
sets aMany fields of a currently read / open item to aText
*/
void CContactsRamTest::SetManyFieldsL(const TDesC& aText, const TInt aMany, CContactItemFieldSet &fields)
{
TInt count = fields.Count();
if( count > aMany )
{
count = aMany;
}
TInt i = 0;
for(; i < count; ++i)
{
SetFieldL(fields[i],aText);
}
}
/**Utility function for Adding any number of contact items
with name and telephone fields.
*/
void CAgentTest::AddContactItemsL(TInt aCount)
{
iIdArray->Reset();
CContactItem* templateCard = NULL;
CContactCard* card = NULL;
CContactItemFieldSet* fieldSet = NULL;
for(TInt loop = 0; loop < aCount; ++loop)
{
TInt pos = KErrNotFound;
TBuf<16> name;
name.Format(_L("NAME%d"),loop);
TBuf<16> tel;
tel.Format(_L("123456%d"),loop);
templateCard = iDb->ReadContactLC(iDb->TemplateId());
card = CContactCard::NewLC(templateCard);
fieldSet = &card->CardFields();
pos = fieldSet->Find(KUidContactFieldFamilyName);
if (pos != KErrNotFound)
{
(*fieldSet)[pos].TextStorage()->SetTextL(name);
}
pos = fieldSet->Find(KUidContactFieldPhoneNumber);
if (pos != KErrNotFound)
{
(*fieldSet)[pos].TextStorage()->SetTextL(tel);
}
TContactItemId contactId = iDb->AddNewContactL(*card);
iIdArray->AddL(contactId);
CleanupStack::PopAndDestroy(2);
}
}
void PrintFieldsTableL(RFile& outFile, const CContactItemFieldSet& fldSet, TBuf8<255>& buf)
{
SDescArr sTStorageType[] = {
_S("KStorageTypeText"),
_S("KStorageTypeStore"),
_S("KStorageTypeContactIt"),
_S("KStorageTypeDateTime")
};
SFlagsDict sFieldFlag[]= {
FF(EHidden),
FF(EReadOnly),
FF(ESynchronize),
FF(EDisabled),
FF(EUserMask),
FF(EOverRidesLabel),
FF(EUsesTemplateData),
FF(EUserAddedField),
FF(ETemplate),
FF(ELabelUnspecified),
FF(EDeleted),
FF(NbTestLast)
};
outFile.Write(_L8("<html><body><table width=100% cellpadding=1 cellspacing=1 border=1>"));
outFile.Write(_L8("<tr><td>Fld</td><td>Label</td><td>Field types:</td><td>Storg type</td>" \
"<td>Field</td><td>Attr</td><td>Ext.Att</td><td>Templ</td></tr>\r\n"));
const TInt numOfFields = fldSet.Count();
for (TInt i=0; i < numOfFields; ++i)
{
const CContactItemField& field = fldSet[i];
const CMyField& myField = reinterpret_cast<const CMyField&>(field);
const CContentType& conType = *myField.iContentType;
buf.Format(_L8("<tr><td>%d</td>"), myField.iId);
outFile.Write(buf);
outFile.Write(_L8("<td>"));
if (myField.iLabel)
{
buf.Copy(*myField.iLabel);
outFile.Write(buf);
}
outFile.Write(_L8("</td>\r\n"));
//test.Printf(_L("Field types are:"));
outFile.Write(_L8("<td>"));
for(TInt j=0; j < conType.FieldTypeCount(); ++j)
{
const TFieldType& fldType = conType.FieldType(j);
//test.Printf(_L(" %s"), VCardMaping(fldType));
const TPtrC str = VCardMaping(fldType);
buf.Copy(str);
outFile.Write(buf);
outFile.Write(_L8(",<br>"));
}
//Print Mapping of the field
outFile.Write(_L8("MP>: "));
const TPtrC mapp = VCardMaping(conType.Mapping());
buf.Copy(mapp);
outFile.Write(buf);
outFile.Write(_L8("</td>\r\n<td>"));
//test.Printf(_L("Storg type: %s"), sTStorageType[myField.iStorageType]);
const TPtrC str (sTStorageType[myField.iStorageType]);
buf.Copy(str);
outFile.Write(buf);
outFile.Write(_L8("</td>\r\n<td>"));
switch(myField.iStorageType)
{
case KStorageTypeText:
{
const TPtrC& textFld = static_cast<CContactTextField*>(field.Storage())->Text();
//test.Printf(_L("Text : %S"), textFld);
buf.Copy(textFld);
outFile.Write(buf);
}
break;
default:
break;
}
outFile.Write(_L8("</td>\r\n"));
//test.Printf(_L("Attributes: 0x%08x"), myField.iAttributes);
buf.Format(_L8("<td>0x%08x"), myField.iAttributes);
outFile.Write(buf);
for (TInt i = 0;; ++i)
{
const SFlagsDict& aFlag = sFieldFlag[i];
if (aFlag.iFlag & myField.iAttributes)
{
TPtrC str(aFlag.iDescript);
buf.Copy(str);
outFile.Write(_L8(",<br>"));
outFile.Write(buf);
}
if (aFlag.iFlag == NbTestLast)
{
break;
}
}
outFile.Write(_L8("</td>\r\n"));
//test.Printf(_L("Ext Attrib: 0x%08x"), myField.iExtendedAttributes);
buf.Format(_L8("<td>0x%08x</td>\r\n"), myField.iExtendedAttributes);
outFile.Write(buf);
//test.Printf(_L("Temp fldId: 0x%08x"), myField.iTemplateFieldId);
buf.Format(_L8("<td>%d</td>\r\n"), myField.iTemplateFieldId);
outFile.Write(buf);
outFile.Write(_L8("</tr>\r\n\r\n"));
}
outFile.Write(_L8("</table></body></html>\r\n"));
}
static void PhonebookWriteReqL(PktBuf &in, PktBuf &out)
{
TUint16 memtype, ns, type, subtype;
TUint32 location;
CContactItem *item;
CContactItemFieldSet *fieldset;
CContactItemField *field;
TBuf<64> name;
TPtrC family_name, given_name;
int i, s;
g->InitPhoneBookL();
in >> memtype;
in >> location;
if (memtype != GN_MT_ME) {
out << (TUint16)GNAPPLET_MSG_PHONEBOOK_WRITE_RESP;
out << (TUint16)GN_ERR_INVALIDMEMORYTYPE;
return;
}
fieldset = CContactItemFieldSet::NewLC();
in >> ns;
for (i = 0; i < ns; i++) {
in >> type >> subtype >> name;
switch (type) {
case GN_PHONEBOOK_ENTRY_Name:
for (s = 0; s < name.Length() && name[s] != ' '; s++) ;
if (s >= 1 && s < name.Length()) {
family_name.Set(name.Ptr(), s);
given_name.Set(name.Ptr() + s + 1, name.Length() - s - 1);
} else {
family_name.Set(name);
}
if (family_name.Length() > 0) {
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldFamilyName);
//field->SetLabelL(_L("alma"));
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(family_name);
fieldset->AddL(*field);
}
if (given_name.Length() > 0) {
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldGivenName);
//field->SetLabelL(_L("alma"));
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(given_name);
fieldset->AddL(*field);
}
break;
case GN_PHONEBOOK_ENTRY_Email:
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldEMail);
field->SetMapping(KUidContactFieldVCardMapEMAILINTERNET);
field->TextStorage()->SetTextL(name);
fieldset->AddL(*field);
break;
case GN_PHONEBOOK_ENTRY_Note:
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldNote);
field->SetMapping(KUidContactFieldVCardMapNOTE);
field->TextStorage()->SetTextL(name);
fieldset->AddL(*field);
break;
case GN_PHONEBOOK_ENTRY_Number:
if (subtype == GN_PHONEBOOK_NUMBER_Fax) {
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldFax);
field->SetMapping(KUidContactFieldVCardMapTEL);
field->AddFieldTypeL(KUidContactFieldVCardMapFAX);
} else {
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldPhoneNumber);
field->SetMapping(KUidContactFieldVCardMapTEL);
switch (subtype) {
case GN_PHONEBOOK_NUMBER_Home:
field->AddFieldTypeL(KUidContactFieldVCardMapHOME);
break;
case GN_PHONEBOOK_NUMBER_Mobile:
field->AddFieldTypeL(KUidContactFieldVCardMapCELL);
break;
case GN_PHONEBOOK_NUMBER_Work:
field->AddFieldTypeL(KUidContactFieldVCardMapWORK);
break;
}
}
field->TextStorage()->SetTextL(name);
fieldset->AddL(*field);
break;
case GN_PHONEBOOK_ENTRY_Ringtone:
//field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldRingTone);
//field->TextStorage()->SetTextL(name);
//fieldset->AddL(*field);
break;
case GN_PHONEBOOK_ENTRY_Group:
//field = CContactItemField::NewL(KStorageTypeText,
//field->TextStorage()->SetTextL(name);
//fieldset->AddL(*field);
break;
case GN_PHONEBOOK_ENTRY_URL:
field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldUrl);
field->SetMapping(KUidContactFieldVCardMapURL);
field->TextStorage()->SetTextL(name);
fieldset->AddL(*field);
break;
default:
break;
}
}
in.FinishL();
TRAPD(error, item = g->cdb->OpenContactL(location));
if (error == KErrNone) {
item->UpdateFieldSet(fieldset);
CleanupStack::Pop(fieldset);
CleanupStack::PushL(item);
g->cdb->CommitContactL(*item);
} else {
item = CContactCard::NewL();
item->UpdateFieldSet(fieldset);
CleanupStack::Pop(fieldset);
CleanupStack::PushL(item);
location = g->cdb->AddNewContactL(*item);
}
CleanupStack::Pop(item);
out << (TUint16)GNAPPLET_MSG_PHONEBOOK_WRITE_RESP;
out << (TUint16)GN_ERR_NONE;
out << memtype;
out << location;
cons->Printf(_L("write: %d\n"), location);
}
/**
Test: opens contact item, add two identical uids to each field,
alternating between custom and existing uids,
then checks if uids were stored correctly
*/
void CCustomLabelUid::DuplicateUidsTestL( const TContactItemId aCid )
{
//open contact
CContactItem *contactItem = NULL;
contactItem = iContactsDatabase->OpenContactLX(aCid,*iViewAll);
CleanupStack::PushL(contactItem);
CContactItemFieldSet *contactFields = &(contactItem->CardFields());
//add two identical uids to each field, alternating between custom and existing uids
const TInt KFieldsCount = contactFields->Count();
TInt error = KErrNone;
//add duplicate custom uids
CContactItemField *contactField1 = CContactItemField::NewL(KStorageTypeText);
CleanupStack::PushL(contactField1);
contactField1->SetTemplateField(EFalse);
TRAP( error, contactField1->AddFieldTypeL( TFieldType::Uid(TestConstants::KInitialUID) ));
INTCOMPARE( KErrNone, ==, error, 0, 0 );
TRAP( error, contactField1->AddFieldTypeL( TFieldType::Uid(TestConstants::KInitialUID) ));
INTCOMPARE( KErrNone, ==, error, 0, 0 );
contactItem->AddFieldL(*contactField1);
CleanupStack::Pop(contactField1);
//add duplicate existing uids
CContactItemField *contactField2 = CContactItemField::NewL(KStorageTypeText);
CleanupStack::PushL(contactField2);
contactField2->SetTemplateField(EFalse);
TRAP( error, contactField2->AddFieldTypeL(KUidContactFieldAdditionalName));
INTCOMPARE( KErrNone, ==, error, 1, 0 );
TRAP( error, contactField2->AddFieldTypeL(KUidContactFieldAdditionalName));
INTCOMPARE( KErrNone, ==, error, 1, 0 );
contactItem->AddFieldL(*contactField2);
CleanupStack::Pop(contactField2);
//populate contact fields
SetContactFieldsL(*contactItem);
//update contact
iContactsDatabase->CommitContactL(*contactItem);
CleanupStack::PopAndDestroy(contactItem);
CleanupStack::Pop();//lock
contactItem = NULL;
//read contact item
contactItem = iContactsDatabase->ReadContactLC(aCid,*iViewAll);
contactFields = &(contactItem->CardFields());
//check that contact field uids updated correctly
const TInt KReadFieldsCount = contactFields->Count();
const CContentType *KContentType = NULL;
INTCOMPARE( KReadFieldsCount, >, 0, 0, 0 );
KContentType = &(*contactFields)[KFieldsCount].ContentType();
SINGLECOMPARE( KContentType->ContainsFieldType( TFieldType::Uid(TestConstants::KInitialUID) ), KFieldsCount,0 );
KContentType = &(*contactFields)[KFieldsCount+1].ContentType();
SINGLECOMPARE( KContentType->ContainsFieldType(KUidContactFieldAdditionalName), KFieldsCount+1,0 );
//check that contact fields updated correctly
SINGLECOMPARE( CheckContactFieldsL(*contactItem), 0, 0 );
CleanupStack::PopAndDestroy(contactItem);
}